@payconductor/houndsman 0.7.0 → 0.8.0

package/src/server/client/Sidebar.tsx

@@ -24,6 +24,7 @@ import type {
 	CheckoutResponse,
 	PrListItem,
 	PrListResponse,
+	PrWorktreeResponse,
 	RunSummary,
 	WorktreeState,
 } from "./utils/types";
@@ -89,9 +90,11 @@ function PrItem({
 	worktree,
 	busy,
 	confirming,
+	worktreeBusy,
 	onConfirm,
 	onCancel,
 	onCheckout,
+	onCreateWorktree,
 	onSelectRun,
 }: {
 	pr: PrListItem;
@@ -99,9 +102,11 @@ function PrItem({
 	worktree: WorktreeState;
 	busy: boolean;
 	confirming: boolean;
+	worktreeBusy: boolean;
 	onConfirm: (number: number) => void;
 	onCancel: () => void;
 	onCheckout: (pr: PrListItem) => void;
+	onCreateWorktree: (pr: PrListItem) => void;
 	onSelectRun: (slug: string) => void;
 }) {
 	const isCurrent = currentBranch === pr.headRefName;
@@ -130,6 +135,11 @@ function PrItem({
 				<span>· {pr.author}</span>
 			</p>
 			{review && <p class={`pr-review pr-review-${pr.reviewDecision}`}>{review}</p>}
+			{pr.worktreePath && (
+				<p class="pr-worktree" title={pr.worktreePath}>
+					Worktree: <code>{pr.worktreePath}</code>
+				</p>
+			)}
 			<div class="pr-actions">
 				{runSlug && (
 					<button
@@ -141,6 +151,21 @@ function PrItem({
 						Abrir run
 					</button>
 				)}
+				{!pr.worktreePath && (
+					<button
+						type="button"
+						class="pr-btn"
+						disabled={busy || worktreeBusy}
+						title={`Criar um worktree dedicado para ${pr.headRefName} (revisão paralela)`}
+						onClick={() => onCreateWorktree(pr)}
+					>
+						{worktreeBusy ? (
+							<Spinner size={12} class="icon spin" />
+						) : (
+							"Worktree"
+						)}
+					</button>
+				)}
 				{pr.url && (
 					<a
 						class="pr-btn"
@@ -209,6 +234,7 @@ export function Sidebar({
 	const [error, setError] = useState("");
 	const [notice, setNotice] = useState("");
 	const [busy, setBusy] = useState<number | null>(null);
+	const [worktreeBusy, setWorktreeBusy] = useState<number | null>(null);
 	const [confirming, setConfirming] = useState<number | null>(null);
 	const requested = useRef(false);
 
@@ -284,7 +310,34 @@ export function Sidebar({
 		},
 		[loadPrs, onRefreshRuns, onSelect],
 	);
-
+	const createWorktree = useCallback(
+		async (pr: PrListItem) => {
+			setWorktreeBusy(pr.number);
+			setError("");
+			setNotice("");
+			try {
+				const result = await api<PrWorktreeResponse>("/api/prs/worktree", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ number: pr.number }),
+				});
+				if (!result.ok) {
+					setError(result.detail);
+					return;
+				}
+				setNotice(
+					`Worktree de #${pr.number} em ${result.path}. ` +
+						`Rode \`houndsman --pr ${pr.number}\` para revisar em paralelo.`,
+				);
+				await loadPrs();
+			} catch (err) {
+				setError(String(err));
+			} finally {
+				setWorktreeBusy(null);
+			}
+		},
+		[loadPrs],
+	);
 	return (
 		<aside class="sidebar">
 			<div class="brand">
@@ -383,9 +436,11 @@ export function Sidebar({
 								worktree={data.worktree}
 								busy={busy !== null}
 								confirming={confirming === pr.number}
+								worktreeBusy={worktreeBusy === pr.number}
 								onConfirm={setConfirming}
 								onCancel={() => setConfirming(null)}
 								onCheckout={checkout}
+								onCreateWorktree={createWorktree}
 								onSelectRun={onSelect}
 							/>
 						))}

package/src/server/client/icons.tsx

@@ -120,6 +120,16 @@ export const Alert = (p: IconProps) => (
 	</Svg>
 );
 
+/** Lixeira — excluir a run. */
+export const Trash = (p: IconProps) => (
+	<Svg {...p}>
+		<path d="M4 7h16" />
+		<path d="M9 7V4h6v3" />
+		<path d="m6.5 7 1 13h9l1-13" />
+		<path d="M10 11v6M14 11v6" />
+	</Svg>
+);
+
 export const ListIcon = (p: IconProps) => (
 	<Svg {...p}>
 		<path d="M9 6h12M9 12h12M9 18h12" />

package/src/server/client/utils/types.ts

@@ -83,6 +83,9 @@ export type ArtifactMeta = {
 export type RunSummary = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	prNumber?: number;
 	updatedAt?: string;
 	startedAt?: string;
 	/** Último sinal de vida de uma execução ativa (revisão/correção). */
@@ -126,6 +129,8 @@ export type PrListItem = {
 	reviewDecision?: string;
 	url?: string;
 	runSlug?: string;
+	/** Worktree ativo da PR (revisão paralela). */
+	worktreePath?: string;
 };
 
 export type PrListResponse = {
@@ -145,6 +150,27 @@ export type CheckoutResponse =
 			changes?: string[];
 	  };
 
+/** Resultado de `DELETE /api/runs/:slug`. */
+export type DeleteRunResponse = {
+	deleted: boolean;
+	worktreeRequested: boolean;
+	worktreeRemoved: boolean;
+	worktreePath?: string;
+	warning?: string;
+};
+
+export type PrWorktreeResponse =
+	| {
+			ok: true;
+			number: number;
+			branch: string;
+			path: string;
+			head: string;
+			created: boolean;
+			warning?: string;
+	  }
+	| { ok: false; reason: string; detail: string };
+
 /** Comentário normalizado da PR (thread ou geral). */
 export type PrCommentView = {
 	id: number;

package/src/server/index.ts

@@ -17,7 +17,10 @@ import {
 } from "../core/github-review";
 import { logger } from "../core/logging";
 import { GitRepository } from "../core/services/git-repository";
+import { PrResolver } from "../core/services/pr-resolver";
+import { WorktreeManager } from "../core/services/worktree-manager";
 import { createStorage } from "../core/storage/factory";
+import { resolveWorktreesRoot } from "../core/storage/paths";
 import { resolveRepoIdentity } from "../core/storage/repo-identity";
 import type { RepoIdentity, StorageProvider } from "../core/storage/types";
 import { buildClientBundle } from "./client-build";
@@ -94,6 +97,8 @@ async function route(
 	ghRunner: GhRunner,
 	prs: PrInbox,
 	editor: EditorContext,
+	worktrees: WorktreeManager,
+	git: GitRepository,
 ): Promise<Response> {
 	const url = new URL(request.url);
 	const path = url.pathname;
@@ -108,7 +113,61 @@ async function route(
 	if (path === "/api/health") return json({ ok: true });
 	if (path === "/api/editor" && request.method === "GET") return json(editor);
 	if (path === "/api/prs" && request.method === "GET") {
-		return json(prs.list(runs.branchIndex()));
+		return json(prs.list(runs.workspaceIndex()));
+	}
+	if (path === "/api/worktrees" && request.method === "GET") {
+		return json({
+			worktrees: worktrees.managed().map((entry) => ({
+				path: entry.path,
+				branch: entry.branch?.replace(/^refs\/heads\//, "") ?? null,
+				head: entry.head ?? null,
+				prunable: entry.prunable,
+			})),
+		});
+	}
+	if (path === "/api/prs/worktree" && request.method === "POST") {
+		const body = (await request.json().catch(() => ({}))) as { number?: unknown };
+		const number = Number(body.number);
+		if (!Number.isInteger(number) || number <= 0) {
+			return json(
+				{ ok: false, reason: "invalid", detail: "Número de PR inválido." },
+				400,
+			);
+		}
+		const resolver = new PrResolver(ghRunner, git);
+		const resolved = resolver.resolve(number);
+		if (!resolved.ok) {
+			return json({ ok: false, reason: resolved.reason, detail: resolved.detail });
+		}
+		const refs = resolver.prepareRefs(resolved.pr);
+		try {
+			const worktree = worktrees.ensure({
+				branch: resolved.pr.headRefName,
+				ref: refs.head,
+			});
+			return json({
+				ok: true,
+				number,
+				branch: resolved.pr.headRefName,
+				path: worktree.path,
+				head: worktree.head,
+				created: worktree.created,
+				warning: refs.warning,
+			});
+		} catch (error) {
+			return json({
+				ok: false,
+				reason: "git",
+				detail: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+	const worktreeMatch = path.match(/^\/api\/worktrees\/(.+)$/);
+	if (worktreeMatch && request.method === "DELETE") {
+		const branch = decodeURIComponent(worktreeMatch[1]);
+		const force = url.searchParams.get("force") === "1";
+		const result = worktrees.remove(branch, { force });
+		return json(result, result.removed ? 200 : 409);
 	}
 	if (path === "/api/prs/checkout" && request.method === "POST") {
 		const body = (await request.json().catch(() => ({}))) as { number?: unknown };
@@ -132,6 +191,14 @@ async function route(
 	const rest = match[2] ?? "";
 	if (!runs.exists(slug)) return notFound(`run '${slug}' não encontrada`);
 
+	if (rest === "" && request.method === "DELETE") {
+		const removeWorktree = ["1", "true"].includes(
+			url.searchParams.get("worktree") ?? "",
+		);
+		const result = runs.delete(slug, { removeWorktree });
+		return result ? json(result) : notFound(`run '${slug}' não encontrada`);
+	}
+
 	if (rest === "" || rest === "/") return json(runs.detail(slug));
 
 	if (rest === "/comments" && request.method === "GET") {
@@ -195,25 +262,44 @@ export class HoundsmanServer {
 	private readonly ghRunner: GhRunner;
 	private readonly prs: PrInbox;
 	private readonly editor: EditorContext;
+	private readonly worktrees: WorktreeManager;
+	private readonly git: GitRepository;
 
 	constructor(config: HoundsmanConfig, deps: ServerDeps = {}) {
 		const repo = deps.repo ?? resolveRepoIdentity();
 		this.ghRunner = deps.ghRunner ?? defaultGhRunner;
+		this.git = new GitRepository(deps.gitRunner ?? createGitRunner(repo.root));
+		this.prs = new PrInbox(this.ghRunner, this.git);
+		this.worktrees = new WorktreeManager(
+			new GitRepository(createGitRunner(repo.root)),
+			{
+				repoKey: repo.key,
+				repoRoot: repo.root,
+				baseDir: resolveWorktreesRoot(config.worktrees?.location, repo.root),
+			},
+		);
 		this.runs = new RunRepository(
 			deps.storage ?? createStorage(config),
 			repo,
 			this.ghRunner,
+			this.worktrees,
 		);
 		this.editor =
 			deps.editor ?? resolveEditor(deps.editorPreference, process.env, repo.root);
-		const git = new GitRepository(deps.gitRunner ?? createGitRunner(repo.root));
-		this.prs = new PrInbox(this.ghRunner, git);
 	}
 
 	/** Handler de requisições (testável sem abrir porta). */
 	readonly handler = async (request: Request): Promise<Response> => {
 		try {
-			return await route(request, this.runs, this.ghRunner, this.prs, this.editor);
+			return await route(
+				request,
+				this.runs,
+				this.ghRunner,
+				this.prs,
+				this.editor,
+				this.worktrees,
+				this.git,
+			);
 		} catch (error) {
 			return json(
 				{ error: error instanceof Error ? error.message : String(error) },
@@ -423,6 +509,13 @@ code, pre, .mono { font-family:var(--font-mono); tab-size:4; }
   transition:background .15s ease, border-color .15s ease, color .15s ease; }
 .btn:hover { background:#202027; border-color:var(--accent-line); }
 .btn:disabled { opacity:.55; cursor:not-allowed; }
+.btn.danger { color:#ffb3b3; background:rgba(255,86,86,.12); border-color:rgba(255,86,86,.4); }
+.btn.danger:hover { background:rgba(255,86,86,.2); border-color:rgba(255,86,86,.62); }
+.modal-check { display:flex; align-items:flex-start; gap:10px; padding:12px 14px; font-size:12.5px; line-height:1.55;
+  color:var(--fg); background:var(--surface-2); border:1px solid var(--border); border-radius:12px; cursor:pointer; }
+.modal-check input { margin:3px 0 0; flex:none; accent-color:var(--accent); }
+.modal-check code { font-family:var(--font-mono); font-size:11.5px; color:var(--muted); word-break:break-all; }
+.modal-warn { margin:0; font-size:12px; line-height:1.55; color:var(--muted); }
 .icon.spin { animation:spin .8s linear infinite; }
 .content { width:100%; max-width:1180px; margin:0 auto; padding:22px 24px 64px; }
 .page-header { display:flex; align-items:flex-start; justify-content:space-between; gap:18px; margin-bottom:16px; }

package/src/server/pr-inbox.ts

@@ -19,6 +19,13 @@ export type WorktreeState = {
 	sample: string[];
 };
 
+/** Run associada à branch de uma PR. */
+export type PrRunInfo = {
+	slug: string;
+	worktreePath?: string;
+	prNumber?: number;
+};
+
 /** PR aberta exibida na sidebar. */
 export type PrListItem = {
 	number: number;
@@ -32,6 +39,8 @@ export type PrListItem = {
 	url?: string;
 	/** Run local correspondente à branch, quando existir. */
 	runSlug?: string;
+	/** Worktree ativo da PR (revisão paralela). */
+	worktreePath?: string;
 };
 
 /** Resposta de `GET /api/prs`. */
@@ -70,11 +79,12 @@ type GhPrListItem = {
 
 function toItem(
 	raw: GhPrListItem,
-	runSlugs: ReadonlyMap<string, string>,
+	runs: ReadonlyMap<string, PrRunInfo>,
 ): PrListItem | null {
 	const number = Number(raw.number);
 	const headRefName = raw.headRefName?.trim();
 	if (!Number.isFinite(number) || number <= 0 || !headRefName) return null;
+	const run = runs.get(headRefName);
 	return {
 		number,
 		title: raw.title?.trim() || `PR #${number}`,
@@ -85,7 +95,8 @@ function toItem(
 		isDraft: Boolean(raw.isDraft),
 		reviewDecision: raw.reviewDecision?.trim() || undefined,
 		url: raw.url,
-		runSlug: runSlugs.get(headRefName),
+		runSlug: run?.slug,
+		worktreePath: run?.worktreePath,
 	};
 }
 
@@ -115,7 +126,7 @@ export class PrInbox {
 	}
 
 	/** Lista as PRs abertas (limite 50) e o estado local do repositório. */
-	list(runSlugs: ReadonlyMap<string, string> = new Map()): PrListResponse {
+	list(runs: ReadonlyMap<string, PrRunInfo> = new Map()): PrListResponse {
 		const currentBranch = this.git.currentBranch();
 		const worktree = this.worktree();
 		const result = this.ghRunner([
@@ -162,7 +173,7 @@ export class PrInbox {
 		}
 
 		const prs = (parsed as GhPrListItem[])
-			.map((item) => toItem(item, runSlugs))
+			.map((item) => toItem(item, runs))
 			.filter((item): item is PrListItem => item !== null)
 			.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
 

package/src/server/run-repository.ts

@@ -5,6 +5,7 @@
  * O slug continua sendo o branch-slug (estável nas URLs).
  */
 
+import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import {
 	applyFindingUpdate,
@@ -35,7 +36,10 @@ import {
 import { pingFindingsStatus } from "../core/run-status";
 import { systemClock } from "../core/services/clock";
 import { defaultGhRunner } from "../core/services/gh-client";
+import type { WorktreeManager } from "../core/services/worktree-manager";
+import { workRoot } from "../core/storage/paths";
 import type { RepoIdentity, ReviewRecord, StorageProvider } from "../core/storage/types";
+import { ReviewWorkArea } from "../core/storage/work-area";
 import type { Severity } from "../core/types";
 import { isSlug } from "./artifacts";
 import { fetchPrComments, type PrCommentsResponse } from "./pr-comments";
@@ -44,6 +48,10 @@ import { fetchPrComments, type PrCommentsResponse } from "./pr-comments";
 export type RunListItem = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	/** PR revisada (quando iniciada via `--pr`). */
+	prNumber?: number;
 	updatedAt?: string;
 	startedAt?: string;
 	heartbeatAt?: string;
@@ -55,6 +63,10 @@ export type RunListItem = {
 export type RunDetail = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	/** PR revisada (quando iniciada via `--pr`). */
+	prNumber?: number;
 	status: ReviewRecord | null;
 	manifest: unknown;
 	summary: FindingsSummary;
@@ -63,6 +75,18 @@ export type RunDetail = {
 	deleted: string[];
 };
 
+/** Resultado da exclusão de uma run. */
+export type DeleteRunResult = {
+	deleted: boolean;
+	/** O usuário pediu para remover o worktree. */
+	worktreeRequested: boolean;
+	/** O worktree foi de fato removido. */
+	worktreeRemoved: boolean;
+	worktreePath?: string;
+	/** Aviso quando o worktree não pôde ser removido. */
+	warning?: string;
+};
+
 /** Resultado do envio dos findings à PR. */
 export type SubmitResult =
 	| { available: false; reason: string }
@@ -81,15 +105,18 @@ export class RunRepository {
 	private readonly storage: StorageProvider;
 	private readonly repo: RepoIdentity;
 	private readonly ghRunner: GhRunner;
+	private readonly worktrees?: WorktreeManager;
 
 	constructor(
 		storage: StorageProvider,
 		repo: RepoIdentity,
 		ghRunner: GhRunner = defaultGhRunner,
+		worktrees?: WorktreeManager,
 	) {
 		this.storage = storage;
 		this.repo = repo;
 		this.ghRunner = ghRunner;
+		this.worktrees = worktrees;
 	}
 
 	/** `true` se o slug aponta para uma run do repositório atual. */
@@ -104,6 +131,8 @@ export class RunRepository {
 			return {
 				slug: review.slug,
 				branch: review.branch,
+				worktreePath: review.worktreePath,
+				prNumber: review.prNumber,
 				updatedAt: review.updatedAt,
 				startedAt: review.startedAt,
 				heartbeatAt: review.heartbeatAt,
@@ -122,6 +151,23 @@ export class RunRepository {
 		);
 	}
 
+	/** Mapa branch → run + worktree (sidebar de PRs). */
+	workspaceIndex(): Map<
+		string,
+		{ slug: string; worktreePath?: string; prNumber?: number }
+	> {
+		return new Map(
+			this.storage.listReviews(this.repo.key).map((review) => [
+				review.branch,
+				{
+					slug: review.slug,
+					worktreePath: review.worktreePath,
+					prNumber: review.prNumber,
+				},
+			]),
+		);
+	}
+
 	/** Detalhe da run (null se o slug for inválido). */
 	detail(slug: string): RunDetail | null {
 		const review = this.findBySlug(slug);
@@ -135,6 +181,8 @@ export class RunRepository {
 		return {
 			slug: review.slug,
 			branch: review.branch,
+			worktreePath: review.worktreePath,
+			prNumber: review.prNumber,
 			status: review,
 			manifest: this.readArtifactJson(review, "manifest.json"),
 			summary: summarize(state),
@@ -144,6 +192,49 @@ export class RunRepository {
 		};
 	}
 
+	/**
+	 * Apaga a run por completo: staging local, findings, histórico, artefatos e a
+	 * review. Opcionalmente remove o worktree (com `--force`, pois a run foi
+	 * confirmada para exclusão).
+	 */
+	delete(
+		slug: string,
+		options: { removeWorktree?: boolean } = {},
+	): DeleteRunResult | null {
+		const review = this.findBySlug(slug);
+		if (!review) return null;
+
+		const worktreePath = review.worktreePath;
+		const removeWorktree = options.removeWorktree === true && Boolean(worktreePath);
+		let worktreeRemoved = false;
+		let warning: string | undefined;
+
+		if (removeWorktree && worktreePath) {
+			if (this.worktrees) {
+				const result = this.worktrees.remove(worktreePath, { force: true });
+				worktreeRemoved = result.removed;
+				if (!result.removed) {
+					warning = result.detail ?? "worktree não removido";
+				}
+			} else {
+				warning = "worktree não gerenciado por este servidor";
+			}
+		}
+
+		// Staging atual (dentro do worktree quando existe) + legado no home.
+		new ReviewWorkArea(review).clean();
+		new ReviewWorkArea(review, workRoot()).clean();
+
+		this.storage.deleteReview(review.id);
+		return {
+			deleted: true,
+			worktreeRequested: options.removeWorktree === true,
+			worktreeRemoved,
+			worktreePath,
+			warning,
+		};
+	}
+
 	/** Aplica `VACUUM`/`optimize` no backend (chamado no start do server). */
 	maintain(): void {
 		this.storage.maintain();
@@ -171,6 +262,12 @@ export class RunRepository {
 		return this.storage.readFindings(review.id) ?? emptyState(review.branch);
 	}
 
+	/** Raiz dos arquivos da review: worktree vivo ou clone principal. */
+	private rootOf(review: ReviewRecord): string {
+		const worktree = review.worktreePath;
+		return worktree && existsSync(worktree) ? worktree : this.repo.root;
+	}
+
 	private readArtifactJson<T>(review: ReviewRecord, name: string): T | null {
 		const artifact = this.storage.readArtifact(review.id, name);
 		if (!artifact) return null;
@@ -252,7 +349,7 @@ export class RunRepository {
 		const review = this.findBySlug(slug);
 		if (!review) return null;
 		const state = this.loadState(review);
-		const result = syncState(state, fileReader(process.cwd()));
+		const result = syncState(state, fileReader(this.rootOf(review)));
 		this.storage.writeFindings(review.id, state);
 		pingFindingsStatus(this.storage, review.id, state);
 		return { result, summary: summarize(state) };
@@ -336,5 +433,9 @@ function toClientFinding(
 	finding: FindingState,
 	review: ReviewRecord,
 ): FindingState & { absFile: string } {
-	return { ...finding, absFile: resolve(review.repoRoot, finding.file) };
+	const root =
+		review.worktreePath && existsSync(review.worktreePath)
+			? review.worktreePath
+			: review.repoRoot;
+	return { ...finding, absFile: resolve(root, finding.file) };
 }

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