beflow 0.1.0 → 0.2.0

package/src/cli.ts

@@ -8,6 +8,7 @@ import type { ArgsDef, CommandContext, CommandDef } from "citty";
 import { AcpxDriver, resolveAcpCommand, resolveAcpxCommand } from "./agent/acpx.ts";
 import type { AgentDriver } from "./agent/driver.ts";
 import { loadConfig, loadRegistry } from "./config/load.ts";
+import { configDir } from "./config/paths.ts";
 import type { Config, Registry } from "./config/schema.ts";
 import { ConfigStore, nodeConfigWatcher } from "./config/store.ts";
 import type { ConfigWatcher } from "./config/store.ts";
@@ -172,9 +173,9 @@ interface CliContext {
 // Builds the CliContext shared by every command that needs a tracker + prompts.
 // Config is loaded here (inside command `run` handlers) rather than in `runCli`
 // so that `--help` — which citty resolves without invoking `run` — works even
-// when config.json is missing or invalid.
+// when ~/beflow/config.json is missing or invalid.
 function loadContext(deps: CliDeps, log: (msg: string) => void, fail: (msg: string) => number): CliContext {
-    const dir = deps.cwd ?? process.cwd();
+    const dir = deps.cwd ?? configDir();
     const config = deps.loadConfig(dir);
     const registry = deps.loadRegistry(dir);
     const tracker = deps.createTracker(config, registry);
@@ -356,7 +357,7 @@ function buildCli(deps: CliDeps): Cli {
             cmdGc(
                 { force: asBool(args.force), olderThan: asStr(args["older-than"]), prune: asBool(args.prune) },
                 deps,
-                deps.cwd ?? process.cwd(),
+                deps.cwd ?? configDir(),
                 makeLog(deps),
             ),
     });
@@ -581,7 +582,7 @@ function cmdRuns(args: { key?: string | undefined }, ctx: CliContext): number {
 
 async function cmdSetup(args: { project: string; prune?: boolean | undefined }, ctx: CliContext): Promise<number> {
     const { tracker, config, registry, dir, log } = ctx;
-    const agents = [...new Set([config.defaults.agent, ...Object.keys(config.agents)])].sort();
+    const agents = [...new Set([config.agent, ...Object.keys(config.agents)])].sort();
     await setupProject(args.project, {
         agents,
         dir,
@@ -732,7 +733,7 @@ function resolveEnrich(project: string, ctx: CliContext): EnrichIssue | undefine
     }
     const enrichPrompt = loadEnrichPrompt(defaultPromptResolveDeps(ctx.dir, ctx.config.prompts?.dir));
     return defaultEnrichIssue({
-        defaultAgent: ctx.config.defaults.agent,
+        defaultAgent: ctx.config.agent,
         driver: ctx.deps.createDriver(resolveAcpxCommand(ctx.config)),
         enrichPrompt,
         log: ctx.log,
@@ -806,7 +807,7 @@ async function cmdGc(
 async function boardChecks(deps: CliDeps, dir: string): Promise<DoctorCheck[]> {
     const config = deps.loadConfig(dir);
     const registry = deps.loadRegistry(dir);
-    const agents = [...new Set([config.defaults.agent, ...Object.keys(config.agents)])].sort();
+    const agents = [...new Set([config.agent, ...Object.keys(config.agents)])].sort();
     const tracker = deps.createTracker(config, registry);
 
     const checks: DoctorCheck[] = [];

package/src/config/load.ts

@@ -1,8 +1,9 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 import type { z } from "zod";
 
+import { CONFIG_BOOTSTRAP, configDir, configPath } from "./paths.ts";
 import { configSchema, fileSchema, registrySchema } from "./schema.ts";
 import type { Config, ConfigFile, Registry } from "./schema.ts";
 
@@ -10,7 +11,20 @@ function loadFile<T>(path: string, schema: z.ZodType<T, z.ZodTypeDef, unknown>):
     let raw: string;
     try {
         raw = readFileSync(path, "utf8");
-    } catch {
+    } catch (err) {
+        if (
+            path === configPath() &&
+            typeof err === "object" &&
+            err !== null &&
+            "code" in err &&
+            err.code === "ENOENT"
+        ) {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, CONFIG_BOOTSTRAP, "utf8");
+            throw new Error(
+                `beflow: created ${path} from the built-in template — fill in your workspace details and re-run`,
+            );
+        }
         throw new Error(`beflow: cannot read config file at ${path}`);
     }
 
@@ -34,12 +48,12 @@ function loadConfigFile(dir: string): ConfigFile {
     return loadFile(join(dir, "config.json"), fileSchema);
 }
 
-export function loadConfig(dir: string = process.cwd()): Config {
+export function loadConfig(dir: string = configDir()): Config {
     const file = loadConfigFile(dir);
     return configSchema.parse({ ...file, agents: file.agents ?? {} });
 }
 
-export function loadRegistry(dir: string = process.cwd()): Registry {
+export function loadRegistry(dir: string = configDir()): Registry {
     const file = loadConfigFile(dir);
     return registrySchema.parse(file);
 }

package/src/config/paths.ts

@@ -0,0 +1,41 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function configDir(): string {
+    return join(homedir(), "beflow");
+}
+
+export function configPath(): string {
+    return join(configDir(), "config.json");
+}
+
+export const CONFIG_BOOTSTRAP: string =
+    JSON.stringify(
+        {
+            $schema: "https://raw.githubusercontent.com/corrm/beflow/main/config.schema.json",
+            agent: "claude",
+            agents: {
+                claude: {
+                    args: ["--dangerously-skip-permissions"],
+                    command: "claude",
+                },
+            },
+            projects: {},
+            runMode: "supervised",
+            tracker: "plane",
+            trackers: {
+                linear: { apiKeyEnv: "LINEAR_API_KEY" },
+                plane: {
+                    apiKeyEnv: "PLANE_API_KEY",
+                    baseUrl: "https://api.plane.so",
+                    workspaceSlug: "your-workspace",
+                },
+            },
+            workspace: {
+                id: "your-workspace-id",
+                slug: "your-workspace",
+            },
+        },
+        null,
+        2,
+    ) + "\n";

package/src/config/persist.ts

@@ -46,7 +46,7 @@ export function addProject(dir: string, key: string, project: Project, deps?: Pe
     const { projects: existingProjects } = projectsExtractSchema.parse(parsed);
 
     if (existingProjects?.[key] !== undefined) {
-        throw new Error(`beflow: project "${key}" already exists in config.json`);
+        throw new Error(`beflow: project "${key}" already exists in ${path}`);
     }
 
     const projects: Record<string, unknown> = { ...existingProjects, [key]: project };

package/src/config/schema.ts

@@ -3,13 +3,6 @@ import { z } from "zod";
 export const runModeSchema = z.enum(["autonomous", "supervised"]);
 export const jobKindSchema = z.enum(["triage", "spec", "implement"]);
 
-export const projectDefaultsSchema = z
-    .object({
-        agent: z.string().optional(),
-        runMode: runModeSchema.optional(),
-    })
-    .optional();
-
 export const routingSchema = z
     .object({
         implement: z.string().optional(),
@@ -18,9 +11,47 @@ export const routingSchema = z
     })
     .optional();
 
+export const prOwnerSchema = z.enum(["beflow", "agent"]);
+
+export const prSchema = z
+    .object({
+        owner: prOwnerSchema.optional(),
+        baseBranch: z.string().optional(),
+    })
+    .optional();
+
+export const policyEvaluatorSchema = z.enum(["globs", "command", "agentowners", "off"]);
+export const policyDecisionSchema = z.enum(["block", "require_approval", "allow"]);
+export const policyOnBlockSchema = z.enum(["comment"]);
+
+export const policyRuleSchema = z.object({
+    paths: z.array(z.string()).optional(),
+    agent: z.string().optional(),
+    decision: policyDecisionSchema,
+});
+
+export const policySchema = z
+    .object({
+        evaluator: policyEvaluatorSchema.optional(),
+        command: z.array(z.string()).optional(),
+        rules: z.array(policyRuleSchema).optional(),
+        agentownersPath: z.string().optional(),
+        onBlock: policyOnBlockSchema.optional(),
+    })
+    .optional();
+
+export type PrConfig = z.infer<typeof prSchema>;
+export type PrOwner = z.infer<typeof prOwnerSchema>;
+export type PolicyConfig = z.infer<typeof policySchema>;
+export type PolicyEvaluator = z.infer<typeof policyEvaluatorSchema>;
+export type PolicyDecision = z.infer<typeof policyDecisionSchema>;
+export type PolicyOnBlock = z.infer<typeof policyOnBlockSchema>;
+export type PolicyRule = z.infer<typeof policyRuleSchema>;
+
 export const projectSchema = z.object({
     default_repo: z.string(),
-    defaults: projectDefaultsSchema,
+    agent: z.string().optional(),
+    runMode: runModeSchema.optional(),
     ci: z.object({ autoReworkOnRed: z.boolean().optional() }).optional(),
     deadLetter: z.object({ maxAttempts: z.number().optional() }).optional(),
     inputQuality: z.object({ minBodyChars: z.number().optional() }).optional(),
@@ -34,6 +65,8 @@ export const projectSchema = z.object({
     module_repo_map: z.record(z.string(), z.string()),
     name: z.string(),
     plane_project_id: z.string().optional(),
+    policy: policySchema,
+    pr: prSchema,
     qualityGate: z.object({ commands: z.array(z.string()).optional() }).optional(),
     repos: z.record(z.string(), z.string()),
     review: z.object({ enabled: z.boolean().optional(), postToPr: z.boolean().optional() }).optional(),
@@ -90,48 +123,51 @@ export const fileSchema = z.object({
             })
             .optional(),
     }),
-    defaults: z.object({
-        agent: z.string(),
-        runMode: runModeSchema,
-        // Optional tracker user id; when set, beflow assigns the issue to this user
-        // As it picks it up (moves it to In Progress), for both --auto and --attend.
-        assignee: z.string().optional(),
-        // Unified dead-letter cap: how many accumulated failed attempts (across crash
-        // Resume + CI rework) before beflow quarantines the item to Needs Input.
-        // Per-project `projects.<KEY>.deadLetter` overrides this global; default 3.
-        deadLetter: z.object({ maxAttempts: z.number().optional() }).optional(),
-        // Opt-in input-quality gate. When `minBodyChars` > 0, a fresh autonomous
-        // Dispatch of a too-thin issue is parked to Needs Input instead of burning an
-        // Agent run. Per-project `projects.<KEY>.inputQuality` overrides this global.
-        inputQuality: z.object({ minBodyChars: z.number().optional() }).optional(),
-        // Inline parent-epic + attachment context into the agent task. Default on; set false to disable.
-        linkedContext: z.boolean().optional(),
-        // How beflow reacts when a human moves a card out of beflow's hands (out of
-        // The started group) while a run is live. `yield` lets the run finish but
-        // Skips writeback so the human's move stands; `abort` additionally cancels
-        // The agent mid-run. Always present after parse thanks to the default.
-        onManualMove: z.enum(["yield", "abort"]).default("yield"),
-        // Opt-in quality gate: project check command(s) run in the worktree before an
-        // Implement `done` report opens a PR / advances to In Review. On RED beflow
-        // Auto-reworks the live agent session once, then re-checks; still-red is failed.
-        // Per-project `projects.<KEY>.qualityGate` overrides this global.
-        qualityGate: z.object({ commands: z.array(z.string()).optional() }).optional(),
-        // Opt-in PR review assist. When `enabled`, watch dispatches a reviewer agent over
-        // In-Review items and posts its findings as an issue comment; `postToPr` also posts
-        // Them on the PR. Per-project `projects.<KEY>.review` overrides this global.
-        review: z.object({ enabled: z.boolean().optional(), postToPr: z.boolean().optional() }).optional(),
-        // Opt-in agent routing by jobkind. Keys are jobkind names; values are agent names
-        // From config.agents. Per-project `projects.<KEY>.routing` overrides this global.
-        routing: routingSchema,
-        // Opt-in SLA aging: minutes an item may sit in Needs Input / In Review before
-        // Beflow re-pings the escalation channel. Per-project `projects.<KEY>.sla`
-        // Overrides this global.
-        sla: z.object({ inReviewMinutes: z.number().optional(), needsInputMinutes: z.number().optional() }).optional(),
-        // Opt-in run telemetry: when `inComment`, beflow appends a compact token/cost
-        // Line to its writeback comment on the issue. Default off. Per-project
-        // `projects.<KEY>.telemetry` overrides this global.
-        telemetry: z.object({ inComment: z.boolean().optional() }).optional(),
-    }),
+    agent: z.string(),
+    runMode: runModeSchema,
+    // Optional tracker user id; when set, beflow assigns the issue to this user
+    // As it picks it up (moves it to In Progress), for both --auto and --attend.
+    assignee: z.string().optional(),
+    // Unified dead-letter cap: how many accumulated failed attempts (across crash
+    // Resume + CI rework) before beflow quarantines the item to Needs Input.
+    // Per-project `projects.<KEY>.deadLetter` overrides this global; default 3.
+    deadLetter: z.object({ maxAttempts: z.number().optional() }).optional(),
+    // Opt-in input-quality gate. When `minBodyChars` > 0, a fresh autonomous
+    // Dispatch of a too-thin issue is parked to Needs Input instead of burning an
+    // Agent run. Per-project `projects.<KEY>.inputQuality` overrides this global.
+    inputQuality: z.object({ minBodyChars: z.number().optional() }).optional(),
+    // Inline parent-epic + attachment context into the agent task. Default on; set false to disable.
+    linkedContext: z.boolean().optional(),
+    // How beflow reacts when a human moves a card out of beflow's hands (out of
+    // The started group) while a run is live. `yield` lets the run finish but
+    // Skips writeback so the human's move stands; `abort` additionally cancels
+    // The agent mid-run. Always present after parse thanks to the default.
+    onManualMove: z.enum(["yield", "abort"]).default("yield"),
+    // PR mechanics. `owner` decides whether beflow or the agent opens the PR
+    // (default `agent`, the current back-compat behavior); `baseBranch` is the
+    // Target branch (`auto` ⇒ detect the repo default branch at runtime).
+    // Per-project `projects.<KEY>.pr` overrides this global.
+    pr: prSchema,
+    // Opt-in quality gate: project check command(s) run in the worktree before an
+    // Implement `done` report opens a PR / advances to In Review. On RED beflow
+    // Auto-reworks the live agent session once, then re-checks; still-red is failed.
+    // Per-project `projects.<KEY>.qualityGate` overrides this global.
+    qualityGate: z.object({ commands: z.array(z.string()).optional() }).optional(),
+    // Opt-in PR review assist. When `enabled`, watch dispatches a reviewer agent over
+    // In-Review items and posts its findings as an issue comment; `postToPr` also posts
+    // Them on the PR. Per-project `projects.<KEY>.review` overrides this global.
+    review: z.object({ enabled: z.boolean().optional(), postToPr: z.boolean().optional() }).optional(),
+    // Opt-in agent routing by jobkind. Keys are jobkind names; values are agent names
+    // From config.agents. Per-project `projects.<KEY>.routing` overrides this global.
+    routing: routingSchema,
+    // Opt-in SLA aging: minutes an item may sit in Needs Input / In Review before
+    // Beflow re-pings the escalation channel. Per-project `projects.<KEY>.sla`
+    // Overrides this global.
+    sla: z.object({ inReviewMinutes: z.number().optional(), needsInputMinutes: z.number().optional() }).optional(),
+    // Opt-in run telemetry: when `inComment`, beflow appends a compact token/cost
+    // Line to its writeback comment on the issue. Default off. Per-project
+    // `projects.<KEY>.telemetry` overrides this global.
+    telemetry: z.object({ inComment: z.boolean().optional() }).optional(),
     // Where `--auto` runs create their per-issue git worktrees. `~` expands to the
     // Home dir; defaults to ~/.beflow/worktrees (outside any repo).
     worktrees: z
@@ -152,6 +188,12 @@ export const fileSchema = z.object({
     // Directory of user-editable prompt templates that override the compiled-in
     // Defaults. `~` expands to home; each `<name>.md` overrides that prompt.
     prompts: z.object({ dir: z.string() }).optional(),
+    // Opt-in post-run policy gate. `evaluator` selects how a finished run's diff is
+    // Judged before its PR is accepted: `globs` matches changed paths against `rules`,
+    // `command` shells out to an external argv, `off` disables the gate (default).
+    // `onBlock` is how a block surfaces (only `comment` for now). Per-project
+    // `projects.<KEY>.policy` overrides this global wholesale.
+    policy: policySchema,
     workspace: workspaceSchema,
     projects: z.record(z.string(), projectSchema),
     agents: agentsMapSchema.optional(),

package/src/core/continuation.ts

@@ -5,6 +5,11 @@ import type { PromptSet } from "./prompts.ts";
 import { renderTemplate } from "./prompts.ts";
 import type { RunRecord } from "./runstore.ts";
 
+const AGENT_OWNED_PR_CONTINUATION_INSTRUCTION =
+    "If a pull request is already open for this item, UPDATE it — do not open a new one.";
+const BEFLOW_OWNED_PR_CONTINUATION_INSTRUCTION =
+    "Push your changes. The existing pull request updates automatically — do NOT run `gh pr create` or `gh pr edit`.";
+
 export interface ContinuationContext {
     newComments: Comment[];
     prUrl?: string;
@@ -43,13 +48,16 @@ export async function assembleContinuation(
     };
 }
 
-export function renderContinuation(prompts: PromptSet, ctx: ContinuationContext): string {
+export function renderContinuation(prompts: PromptSet, ctx: ContinuationContext, beflowOwnsPr = false): string {
     const priorReport =
         ctx.priorReport !== undefined ? `${ctx.priorReport.status} — ${ctx.priorReport.summary}` : "(none)";
     const prUrl = ctx.prUrl ?? "(none)";
     const reviewComments =
         ctx.newComments.length > 0 ? ctx.newComments.map((c) => `- ${c.body}`).join("\n") : "No new comments.";
     return renderTemplate("continuation", prompts.continuation, {
+        pr_continuation_instruction: beflowOwnsPr
+            ? BEFLOW_OWNED_PR_CONTINUATION_INSTRUCTION
+            : AGENT_OWNED_PR_CONTINUATION_INSTRUCTION,
         pr_url: prUrl,
         prior_report: priorReport,
         review_comments: reviewComments,

package/src/core/deadletter.ts

@@ -20,7 +20,7 @@ export function shouldQuarantine(attempts: number, threshold: number): boolean {
 /** Project-over-default-over-3 resolution of the unified dead-letter threshold. */
 export function resolveDeadLetterThreshold(config: Config, registry: Registry, projectKey: string): number {
     const projectMax = registry.projects[projectKey]?.deadLetter?.maxAttempts;
-    const globalMax = config.defaults.deadLetter?.maxAttempts;
+    const globalMax = config.deadLetter?.maxAttempts;
     return projectMax ?? globalMax ?? DEFAULT_MAX_ATTEMPTS;
 }
 

package/src/core/doctor.ts

@@ -20,7 +20,7 @@ export interface DoctorDeps {
 }
 
 const API_KEY_HINT =
-    "mint a personal API token (Plane: Profile → Settings → API tokens; Linear: Settings → API → Personal keys) and put it in .env as";
+    "mint a personal API token (Plane: Profile → Settings → API tokens; Linear: Settings → API → Personal keys) and set it in your shell profile (e.g. ~/.zshrc) as";
 
 export async function doctor(deps: DoctorDeps): Promise<DoctorCheck[]> {
     const checks: DoctorCheck[] = [];
@@ -31,13 +31,13 @@ export async function doctor(deps: DoctorDeps): Promise<DoctorCheck[]> {
         checks.push({
             detail: `loaded; active tracker "${config.tracker}"`,
             level: "pass",
-            name: "config.json",
+            name: "config",
         });
     } catch (err) {
         checks.push({
             detail: err instanceof Error ? err.message : String(err),
             level: "fail",
-            name: "config.json",
+            name: "config",
         });
     }
 
@@ -58,7 +58,7 @@ export async function doctor(deps: DoctorDeps): Promise<DoctorCheck[]> {
         }
     } else {
         checks.push({
-            detail: "skipped — config.json did not load",
+            detail: "skipped — config did not load",
             level: "fail",
             name: "tracker config",
         });

package/src/core/gc.ts

@@ -43,6 +43,10 @@ export interface OrphanWorktree {
     ageDays: number;
     safe: boolean;
     heldReason?: string;
+    // Local branch to delete alongside the worktree. Set only for worktrees
+    // reaped because their run record is in the terminal `blocked` state: the
+    // worktree pins this branch and run.ts already deleted the remote.
+    blockedBranch?: string;
 }
 
 const MS_PER_DAY = 86_400_000;
@@ -64,6 +68,23 @@ function parseSourceRepo(stdout: string): string | undefined {
     return undefined;
 }
 
+// Runs the dirty/unpushed cleanliness check used to decide whether a worktree is
+// safe to reap. `safe` is true only when the worktree is clean and fully pushed;
+// otherwise `heldReason` explains why it is held out of a plain `--prune`.
+async function inspectCleanliness(
+    path: string,
+    git: Exec,
+): Promise<{ dirty: boolean; unpushed: boolean; safe: boolean; heldReason?: string }> {
+    const status = await git("git", ["-C", path, "status", "--porcelain"]);
+    const dirty = status.code !== 0 || status.stdout.trim().length > 0;
+
+    const revList = await git("git", ["-C", path, "rev-list", "HEAD", "--not", "--remotes"]);
+    const unpushed = revList.code !== 0 || revList.stdout.trim().length > 0;
+
+    const heldReason = dirty ? "uncommitted changes" : unpushed ? "unpushed commits" : undefined;
+    return { dirty, safe: !dirty && !unpushed, unpushed, ...(heldReason !== undefined ? { heldReason } : {}) };
+}
+
 async function inspectOrphan(path: string, ageDays: number, git: Exec): Promise<OrphanWorktree> {
     const name = path.slice(path.lastIndexOf("/") + 1);
 
@@ -81,22 +102,25 @@ async function inspectOrphan(path: string, ageDays: number, git: Exec): Promise<
         };
     }
 
-    const status = await git("git", ["-C", path, "status", "--porcelain"]);
-    const dirty = status.code !== 0 || status.stdout.trim().length > 0;
-
-    const revList = await git("git", ["-C", path, "rev-list", "HEAD", "--not", "--remotes"]);
-    const unpushed = revList.code !== 0 || revList.stdout.trim().length > 0;
+    return { ageDays, name, path, repoPath, ...(await inspectCleanliness(path, git)) };
+}
 
-    const reason = dirty ? "uncommitted changes" : unpushed ? "unpushed commits" : undefined;
+// A worktree whose run record is in the terminal `blocked` state: run.ts has
+// already closed the PR + deleted the remote branch, leaving only the local
+// worktree (which pins the local branch). It is reaped under a plain `--prune`
+// only when clean and fully pushed; a dirty/unpushed blocked worktree is held
+// (like an orphan) so a human's uncommitted edits survive a non-`--force` prune.
+async function inspectBlocked(path: string, ageDays: number, git: Exec): Promise<OrphanWorktree> {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const listed = await git("git", ["-C", path, "worktree", "list", "--porcelain"]);
+    const repoPath = listed.code === 0 ? parseSourceRepo(listed.stdout) : undefined;
     return {
         ageDays,
-        dirty,
+        blockedBranch: `beflow/${name}`,
         name,
         path,
-        repoPath,
-        safe: !dirty && !unpushed,
-        unpushed,
-        ...(reason !== undefined ? { heldReason: reason } : {}),
+        ...(await inspectCleanliness(path, git)),
+        ...(repoPath !== undefined ? { repoPath } : {}),
     };
 }
 
@@ -113,15 +137,21 @@ export async function collectOrphans(opts: {
     const clock = opts.clock ?? systemClock;
     const now = clockMs(clock);
 
-    const recorded = new Set(listRecords(opts.runsDir, runsFs).map((r) => sanitizeKey(r.key)));
+    const records = listRecords(opts.runsDir, runsFs);
+    const recorded = new Set(records.map((r) => sanitizeKey(r.key)));
+    const blocked = new Set(records.filter((r) => r.status === "blocked").map((r) => sanitizeKey(r.key)));
 
     const orphans: OrphanWorktree[] = [];
     for (const name of fs.listDirs(opts.worktreesDir)) {
+        const path = join(opts.worktreesDir, name);
+        const ageDays = (now - fs.mtimeMs(path)) / MS_PER_DAY;
+        if (blocked.has(name)) {
+            orphans.push(await inspectBlocked(path, ageDays, opts.git));
+            continue;
+        }
         if (recorded.has(name)) {
             continue;
         }
-        const path = join(opts.worktreesDir, name);
-        const ageDays = (now - fs.mtimeMs(path)) / MS_PER_DAY;
         orphans.push(await inspectOrphan(path, ageDays, opts.git));
     }
     return orphans;
@@ -134,19 +164,25 @@ export interface GcPlan {
 }
 
 async function removeOrphan(orphan: OrphanWorktree, git: Exec, fs: GcFs): Promise<void> {
+    let removedViaGit = false;
     if (orphan.repoPath !== undefined) {
         try {
             await removeWorktree(orphan.repoPath, orphan.path, git);
-            return;
+            removedViaGit = true;
         } catch {
             // `git worktree remove` failed (e.g. locked/corrupt); fall back to
             // a raw recursive delete plus a best-effort prune of the dangling
             // administrative entry in the source repo.
         }
     }
-    fs.removeDir(orphan.path);
-    if (orphan.repoPath !== undefined) {
-        await git("git", ["-C", orphan.repoPath, "worktree", "prune"]);
+    if (!removedViaGit) {
+        fs.removeDir(orphan.path);
+        if (orphan.repoPath !== undefined) {
+            await git("git", ["-C", orphan.repoPath, "worktree", "prune"]);
+        }
+    }
+    if (orphan.blockedBranch !== undefined && orphan.repoPath !== undefined) {
+        await git("git", ["-C", orphan.repoPath, "branch", "-D", orphan.blockedBranch]);
     }
 }
 
@@ -198,11 +234,13 @@ export async function runGc(opts: {
     if (prune) {
         for (const orphan of plan.pruned) {
             await removeOrphan(orphan, opts.git, fs);
-            log(`gc: removed orphan worktree ${orphan.path}`);
+            log(`gc: removed ${orphan.blockedBranch !== undefined ? "blocked" : "orphan"} worktree ${orphan.path}`);
         }
     } else {
         for (const orphan of plan.pruned) {
-            log(`gc: would remove orphan worktree ${orphan.path}`);
+            log(
+                `gc: would remove ${orphan.blockedBranch !== undefined ? "blocked" : "orphan"} worktree ${orphan.path}`,
+            );
         }
     }
 

package/src/core/inputquality.ts

@@ -26,5 +26,5 @@ export function isThinIssue(body: string, minBodyChars: number): boolean {
 }
 
 export function resolveMinBodyChars(config: Config, registry: Registry, projectKey: string): number {
-    return registry.projects[projectKey]?.inputQuality?.minBodyChars ?? config.defaults.inputQuality?.minBodyChars ?? 0;
+    return registry.projects[projectKey]?.inputQuality?.minBodyChars ?? config.inputQuality?.minBodyChars ?? 0;
 }