beflow 0.1.0 → 0.2.0

package/src/core/run.ts

@@ -8,7 +8,7 @@ import type { AgentDriver, AgentRunResult, RunOptions } from "../agent/driver.ts
 import type { Report, ReportStatus } from "../agent/report.ts";
 import type { Config, Project, Registry } from "../config/schema.ts";
 import type { Issue, JobKind, Resolved } from "../model/types.ts";
-import { resolve } from "../resolve/precedence.ts";
+import { resolve, resolvePolicy, resolvePr } from "../resolve/precedence.ts";
 import type { Comment, Tracker } from "../trackers/tracker.ts";
 import { renderContinuation } from "./continuation.ts";
 import { DECISION_HOLD_MESSAGE, isDecisionHeld } from "./decision.ts";
@@ -17,6 +17,10 @@ import { injectAcpxMcp, nodeMcpFs } from "./mcp.ts";
 import type { McpFs, McpServer } from "./mcp.ts";
 import { escalationDetail, notifyEscalation } from "./notify.ts";
 import type { Notifier } from "./notify.ts";
+import { computeChangedFiles, defaultPolicyExec, evaluatePolicy } from "./policy.ts";
+import type { PolicyExec, PolicyResult } from "./policy.ts";
+import { closePrAndDeleteBranch, detectBaseBranch, editPr, hasCommits, markReady, openDraftPr } from "./pr.ts";
+import type { PrRef } from "./pr.ts";
 import type { PromptSet } from "./prompts.ts";
 import { renderContract, renderLinkedContext, renderTask } from "./prompts.ts";
 import { defaultGateExec, resolveQualityGate, runQualityGate } from "./qualitygate.ts";
@@ -24,7 +28,7 @@ import type { GateExec } from "./qualitygate.ts";
 import { deleteRecord, loadRecord, resolveRunsDir, saveRecord, systemClock } from "./runstore.ts";
 import type { Clock, RunRecord, RunStoreFs } from "./runstore.ts";
 import { formatTelemetryLine, resolveTelemetryInComment } from "./runsview.ts";
-import { createWorktree, removeWorktree, resolveWorktreeDir, sanitizeKey } from "./worktree.ts";
+import { bunExec, createWorktree, removeWorktree, resolveWorktreeDir, sanitizeKey } from "./worktree.ts";
 import type { Exec } from "./worktree.ts";
 import { applyReport, buildCommentBody, defaultDoneState } from "./writeback.ts";
 import type { WritebackResult } from "./writeback.ts";
@@ -82,7 +86,7 @@ export async function resolveRun(
 
     const resolved = resolve({
         cli,
-        global: config.defaults,
+        global: config,
         issue: {
             areas: issue.areas,
             state: { group: issue.state.group },
@@ -225,6 +229,8 @@ export interface RunIssueDeps {
     mcpServers?: McpServer[];
     mcpFs?: McpFs;
     gateExec?: GateExec;
+    prExec?: Exec;
+    policyExec?: PolicyExec;
 }
 
 const RESUME_STATUSES: ReadonlySet<RunRecord["status"]> = new Set([
@@ -252,6 +258,18 @@ async function postInReviewInstructionOnce(tracker: Tracker, issue: Issue, log:
     log(`beflow: ${issue.key} → In Review; posted change-request instructions`);
 }
 
+function beflowPrTitle(issue: Issue): string {
+    return `[beflow] ${issue.key}: ${issue.title}`;
+}
+
+function beflowPrBody(issue: Issue, summary?: string): string {
+    const base = `Automated implementation of ${issue.key} by beflow.`;
+    if (summary !== undefined && summary.trim() !== "") {
+        return `${base}\n\n${summary.trim()}`;
+    }
+    return base;
+}
+
 export interface RunResult {
     issue: Issue;
     resolved: Resolved;
@@ -394,6 +412,15 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
     const effectiveRepoPath =
         isResume && prior !== null && prior.repoPath !== undefined ? prior.repoPath : resolved.repoPath;
 
+    // BEFLOW-OWNED PR (opt-in): when the project resolves PR ownership to `beflow`,
+    // The agent only pushes its branch — beflow opens/enriches/marks-ready the PR and
+    // Runs the post-run policy gate. This only engages for an autonomous implement run
+    // With a worktree branch; every other shape keeps the agent-owned behavior.
+    const resolvedPr = resolvePr(deps.config, deps.registry, projectKeyOf(key));
+    const resolvedPolicy = resolvePolicy(deps.config, deps.registry, projectKeyOf(key));
+    const beflowOwned =
+        resolvedPr.owner === "beflow" && useWorktree && effectiveJobKind === "implement" && branch !== undefined;
+
     // attempts counts CONSECUTIVE crash resumes only. A fresh dispatch resets to 0,
     // and a human-driven re-dispatch (rework/answered) passes a continuation, so it
     // also resets to 0 — only an unattended crash-resume increments the streak.
@@ -419,8 +446,8 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
     saveRecord(runsDir, record, deps.runsFs);
 
     await moveToInProgress(deps.tracker, issue);
-    if (deps.config.defaults.assignee !== undefined) {
-        await deps.tracker.assign(issue, deps.config.defaults.assignee);
+    if (deps.config.assignee !== undefined) {
+        await deps.tracker.assign(issue, deps.config.assignee);
     }
 
     const acpCommand = resolveAcpCommand(effectiveAgent, deps.config.agents[effectiveAgent]);
@@ -435,7 +462,7 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
 
     const baseTask =
         renderTask(deps.prompts, issue, resolved.repo) +
-        (await gatherLinkedContext(deps.tracker, issue, deps.config.defaults.linkedContext !== false, log));
+        (await gatherLinkedContext(deps.tracker, issue, deps.config.linkedContext !== false, log));
     const task =
         deps.continuation !== undefined
             ? `${deps.continuation}\n\n${baseTask}`
@@ -446,7 +473,7 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
     const sleep = deps.sleep ?? realSleep;
     const pollMs = deps.manualMovePollMs ?? DEFAULT_MANUAL_MOVE_POLL_MS;
     const poller =
-        deps.config.defaults.onManualMove === "abort"
+        deps.config.onManualMove === "abort"
             ? startManualMovePoller({
                   acpCommand,
                   cwd,
@@ -466,7 +493,7 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
     function buildRunOptions(runTask: string): RunOptions {
         return {
             acpCommand,
-            contract: renderContract(deps.prompts, effectiveJobKind, issue, resolved.repo),
+            contract: renderContract(deps.prompts, effectiveJobKind, issue, resolved.repo, beflowOwned),
             cwd,
             nonInteractive: "fail",
             runMode: "autonomous",
@@ -548,6 +575,68 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
         return formatTelemetryLine(result.stream.usage, telemetryModel, record.attempts);
     }
 
+    // Park the run as FAILED while KEEPING the worktree (and any draft PR): writes the
+    // Failed report back, persists a failed record, and escalates. Used by the
+    // Beflow-owned PR paths (no-op, gh/policy-layer failure) which are all retryable.
+    async function parkBeflowFailed(summary: string): Promise<RunResult> {
+        const failedReport: Report = { status: "failed", summary };
+        const failedApplied = await applyReport(deps.tracker, issue, failedReport, effectiveJobKind, telemetryLine());
+        saveRecord(
+            runsDir,
+            {
+                ...record,
+                attempts: 0,
+                report: failedReport,
+                status: "failed",
+                updatedAt: clock(),
+                ...(result.stream.usage !== undefined ? { usage: result.stream.usage } : {}),
+            },
+            deps.runsFs,
+        );
+        await notifyEscalation(deps.notify, issue, "failed", escalationDetail(failedReport));
+        return { applied: failedApplied, cwd, issue, resolved, result };
+    }
+
+    // BEFLOW-OWNED PR — STEP 1+2 (before the gate): the agent reported `done` and only
+    // Pushed its branch. First confirm it produced commits; if not, the run is empty —
+    // Park failed and keep the worktree (no PR). Otherwise open a DRAFT PR from the
+    // Pushed branch and stamp its URL onto the report so the writeback path links it.
+    // The draft is enriched + marked ready (or closed) by the post-gate policy step.
+    const prExec = deps.prExec ?? bunExec;
+    let openedPr: PrRef | undefined;
+    let beflowBase = "";
+    if (beflowOwned && branch !== undefined && result.report?.status === "done") {
+        try {
+            beflowBase = await detectBaseBranch(resolved.repo, resolvedPr.baseBranch, prExec);
+            if (!(await hasCommits(cwd, beflowBase, prExec))) {
+                log(`beflow: ${key} — agent produced no commits; parking as failed (worktree kept)`);
+                return await parkBeflowFailed(
+                    "The agent reported done but produced no commits on its branch; nothing to open a PR from.",
+                );
+            }
+            openedPr = await openDraftPr(
+                {
+                    base: beflowBase,
+                    body: beflowPrBody(issue),
+                    cwd,
+                    head: branch,
+                    repo: resolved.repo,
+                    title: beflowPrTitle(issue),
+                },
+                prExec,
+            );
+            result = { ...result, report: { ...result.report, prUrl: openedPr.url } };
+            log(`beflow: ${key} — opened draft PR ${openedPr.url}`);
+        } catch (err) {
+            log(
+                `beflow: ${key} — PR layer failed (${err instanceof Error ? err.message : String(err)}); parking as failed (worktree kept)`,
+            );
+            return await parkBeflowFailed(
+                `beflow could not open the pull request: ${err instanceof Error ? err.message : String(err)}`,
+            );
+        }
+    }
+
     // QUALITY GATE (opt-in, autonomous-only): before an implement `done` report is
     // Allowed to open a PR / advance to In Review, run the project check command(s) in
     // The worktree. On RED, re-prompt the SAME live agent session once with the failing
@@ -575,11 +664,15 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
                 id: "quality-gate",
                 isBot: false,
             };
-            const reworkTask = renderContinuation(deps.prompts, {
-                newComments: [gateComment],
-                ...(result.report.prUrl !== undefined ? { prUrl: result.report.prUrl } : {}),
-                priorReport: result.report,
-            });
+            const reworkTask = renderContinuation(
+                deps.prompts,
+                {
+                    newComments: [gateComment],
+                    ...(result.report.prUrl !== undefined ? { prUrl: result.report.prUrl } : {}),
+                    priorReport: result.report,
+                },
+                beflowOwned,
+            );
             const reworked = await deps.driver.run(buildRunOptions(reworkTask), (evt) => {
                 log(`acpx: ${JSON.stringify(evt)}`);
             });
@@ -616,8 +709,13 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
             }
             if (reworked.report?.status === "done" && (reworkGate === undefined || reworkGate.passed)) {
                 // Rework produced a fresh `done` report AND the gate is green (or the
-                // Re-run threw → fail open) — adopt the new report and fall through.
-                result = reworked;
+                // Re-run threw → fail open) — adopt the new report and fall through. In
+                // Beflow-owned mode the agent never sets prUrl, so re-stamp the already
+                // Opened draft PR so the policy + writeback steps still link it.
+                result =
+                    openedPr !== undefined
+                        ? { ...reworked, report: { ...reworked.report, prUrl: openedPr.url } }
+                        : reworked;
             } else {
                 // Still red, or the rework didn't re-emit a `done` report → FAILED. Route
                 // Through applyReport(failed) + escalation, and persist the run record with
@@ -659,6 +757,97 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
         }
     }
 
+    // BEFLOW-OWNED PR — STEP 4 (after a green gate): evaluate the post-run policy over
+    // The run's diff and decide the draft PR's fate. `block` closes the PR + branch and
+    // Routes the issue to the blocked/Needs-Input path (NOT In Review); `require_approval`
+    // Enriches the body but leaves the PR draft as the review artifact; `allow` enriches
+    // And marks it ready. Any thrown PR/policy-layer error parks the run as failed while
+    // Keeping the worktree + draft PR (retryable). Decided here so the shared writeback
+    // Below still moves an allowed/approval run to In Review with the PR linked.
+    let awaitsApproval = false;
+    if (beflowOwned && openedPr !== undefined && branch !== undefined && result.report?.status === "done") {
+        const policyExec = deps.policyExec ?? defaultPolicyExec;
+        let decision: PolicyResult;
+        try {
+            const changedFiles = await computeChangedFiles(cwd, beflowBase, prExec);
+            decision = await evaluatePolicy(
+                {
+                    agent: effectiveAgent,
+                    baseBranch: beflowBase,
+                    changedFiles,
+                    issueKey: key,
+                    jobKind: effectiveJobKind,
+                    repo: resolved.repo,
+                },
+                resolvedPolicy,
+                policyExec,
+                cwd,
+            );
+        } catch (err) {
+            log(
+                `beflow: ${key} — policy layer failed (${err instanceof Error ? err.message : String(err)}); parking as failed (worktree + draft PR kept)`,
+            );
+            return await parkBeflowFailed(
+                `beflow could not evaluate the post-run policy: ${err instanceof Error ? err.message : String(err)}`,
+            );
+        }
+
+        if (decision.decision === "block") {
+            try {
+                await closePrAndDeleteBranch(openedPr, resolved.repo, branch, cwd, prExec);
+            } catch (err) {
+                log(
+                    `beflow: ${key} — closing the blocked PR failed (${err instanceof Error ? err.message : String(err)}); parking as failed`,
+                );
+                return await parkBeflowFailed(
+                    `beflow could not close the policy-blocked pull request: ${err instanceof Error ? err.message : String(err)}`,
+                );
+            }
+            const blockedReport: Report = {
+                status: "blocked",
+                summary: `Policy blocked this change: ${decision.reason}`,
+            };
+            const blockedApplied = await applyReport(
+                deps.tracker,
+                issue,
+                blockedReport,
+                effectiveJobKind,
+                telemetryLine(),
+            );
+            saveRecord(
+                runsDir,
+                {
+                    ...record,
+                    attempts: 0,
+                    report: blockedReport,
+                    status: "blocked",
+                    updatedAt: clock(),
+                    ...(result.stream.usage !== undefined ? { usage: result.stream.usage } : {}),
+                },
+                deps.runsFs,
+            );
+            await notifyEscalation(deps.notify, issue, "blocked", escalationDetail(blockedReport));
+            log(`beflow: ${key} — policy blocked; closed PR + branch and routed to Needs Input`);
+            return { applied: blockedApplied, cwd, issue, resolved, result };
+        }
+
+        try {
+            await editPr(openedPr, resolved.repo, { body: beflowPrBody(issue, result.report.summary) }, prExec);
+            if (decision.decision === "allow") {
+                await markReady(openedPr, resolved.repo, prExec);
+            } else {
+                awaitsApproval = true;
+            }
+        } catch (err) {
+            log(
+                `beflow: ${key} — finalizing the PR failed (${err instanceof Error ? err.message : String(err)}); parking as failed (worktree + draft PR kept)`,
+            );
+            return await parkBeflowFailed(
+                `beflow could not finalize the pull request: ${err instanceof Error ? err.message : String(err)}`,
+            );
+        }
+    }
+
     let applied: WritebackResult | undefined;
     if (result.report !== null) {
         applied = await applyReport(deps.tracker, issue, result.report, effectiveJobKind, telemetryLine());
@@ -686,6 +875,12 @@ export async function runIssue(key: string, cli: Partial<Resolved>, deps: RunIss
                 deps.runsFs,
             );
             await postInReviewInstructionOnce(deps.tracker, issue, log);
+            if (awaitsApproval) {
+                const approvalNote = `This change requires human approval before merge: the draft pull request is the review artifact. Approve it to mark it ready and merge.`;
+                await deps.tracker.comment(issue, approvalNote);
+                await notifyEscalation(deps.notify, issue, "needs_input", approvalNote);
+                log(`beflow: ${key} — policy requires approval; draft PR left for human review`);
+            }
         } else {
             if (worktreeCreated || isResume) {
                 if (git !== undefined) {
@@ -791,8 +986,8 @@ export async function runSupervised(
     const clock = deps.clock ?? systemClock;
 
     await moveToInProgress(deps.tracker, issue);
-    if (deps.config.defaults.assignee !== undefined) {
-        await deps.tracker.assign(issue, deps.config.defaults.assignee);
+    if (deps.config.assignee !== undefined) {
+        await deps.tracker.assign(issue, deps.config.assignee);
     }
 
     const record: RunRecord = {
@@ -818,7 +1013,7 @@ export async function runSupervised(
     const contract = renderContract(deps.prompts, resolved.jobKind, issue, resolved.repo);
     const task =
         renderTask(deps.prompts, issue, resolved.repo) +
-        (await gatherLinkedContext(deps.tracker, issue, deps.config.defaults.linkedContext !== false, log));
+        (await gatherLinkedContext(deps.tracker, issue, deps.config.linkedContext !== false, log));
 
     // Inject the managed `.acpxrc.json` into the repo checkout for the interactive
     // Acpx launch, then restore it in a finally so the user's repo is left exactly
@@ -946,9 +1141,9 @@ export async function runOpen(key: string, cli: Partial<Resolved>, deps: RunOpen
 
     log(`beflow: moving ${key} to In Progress`);
     await moveToInProgress(deps.tracker, issue);
-    if (deps.config.defaults.assignee !== undefined) {
-        log(`beflow: assigning ${key} to ${deps.config.defaults.assignee}`);
-        await deps.tracker.assign(issue, deps.config.defaults.assignee);
+    if (deps.config.assignee !== undefined) {
+        log(`beflow: assigning ${key} to ${deps.config.assignee}`);
+        await deps.tracker.assign(issue, deps.config.assignee);
     }
 
     const record: RunRecord = {
@@ -968,7 +1163,7 @@ export async function runOpen(key: string, cli: Partial<Resolved>, deps: RunOpen
     log(`beflow: launching ${agentCfg.command} in ${cwd}`);
     const task =
         renderTask(deps.prompts, issue, resolved.repo) +
-        (await gatherLinkedContext(deps.tracker, issue, deps.config.defaults.linkedContext !== false, log)) +
+        (await gatherLinkedContext(deps.tracker, issue, deps.config.linkedContext !== false, log)) +
         OPEN_SESSION_TRAILER;
     await openIssue({
         args: agentCfg.args ?? [],

package/src/core/runsview.ts

@@ -5,7 +5,7 @@ import type { RunRecord } from "./runstore.ts";
 // Project-over-default-over-false resolution of the per-project telemetry-in-comment
 // Toggle. Returns false when neither layer opts in.
 export function resolveTelemetryInComment(config: Config, registry: Registry, projectKey: string): boolean {
-    return registry.projects[projectKey]?.telemetry?.inComment ?? config.defaults.telemetry?.inComment ?? false;
+    return registry.projects[projectKey]?.telemetry?.inComment ?? config.telemetry?.inComment ?? false;
 }
 
 // The token count beflow reports: prefer an explicit total, else derive it from

package/src/core/setup.ts

@@ -1,5 +1,6 @@
 import { cancel, confirm, isCancel, select, text } from "@clack/prompts";
 
+import { configDir, configPath } from "../config/paths.ts";
 import { addProject } from "../config/persist.ts";
 import type { Project, Registry } from "../config/schema.ts";
 import type {
@@ -161,7 +162,7 @@ export async function setupProject(projectKey: string, deps: SetupDeps): Promise
         const ask = deps.askProjectSpec ?? (process.stdin.isTTY ? defaultAskProjectSpec : undefined);
         if (ask === undefined) {
             throw new Error(
-                `beflow: project "${projectKey}" is not in config.json; run setup in an interactive terminal to create it`,
+                `beflow: project "${projectKey}" is not in ${configPath()}; run setup in an interactive terminal to create it`,
             );
         }
         const { entry, spec } = await ask({ key: projectKey, tracker: deps.trackerName });
@@ -169,7 +170,7 @@ export async function setupProject(projectKey: string, deps: SetupDeps): Promise
         if (deps.trackerName === "plane" && trackerProjectId !== undefined) {
             entry.plane_project_id = trackerProjectId;
         }
-        (deps.persist ?? addProject)(deps.dir ?? process.cwd(), projectKey, entry);
+        (deps.persist ?? addProject)(deps.dir ?? configDir(), projectKey, entry);
         // The tracker holds a reference to this same registry object; mutate it in
         // place so ensureBoard below sees the freshly created project.
         deps.registry.projects[projectKey] = entry;

package/src/core/sla.ts

@@ -8,7 +8,7 @@ export interface SlaThresholds {
 
 export function resolveSla(config: Config, registry: Registry, projectKey: string): SlaThresholds {
     const projectSla = registry.projects[projectKey]?.sla;
-    const globalSla = config.defaults.sla;
+    const globalSla = config.sla;
     const inReviewMinutes = projectSla?.inReviewMinutes ?? globalSla?.inReviewMinutes;
     const needsInputMinutes = projectSla?.needsInputMinutes ?? globalSla?.needsInputMinutes;
     return {

package/src/core/watch.ts

@@ -1,6 +1,7 @@
 import type { AgentDriver } from "../agent/driver.ts";
 import type { Config, Registry } from "../config/schema.ts";
 import type { Issue, Resolved } from "../model/types.ts";
+import { resolvePr } from "../resolve/precedence.ts";
 import { IssueNotFoundError } from "../trackers/tracker.ts";
 import type { Tracker } from "../trackers/tracker.ts";
 import { assembleContinuation, renderContinuation } from "./continuation.ts";
@@ -394,9 +395,11 @@ export async function watchTick(projectKey: string, deps: WatchDeps): Promise<Wa
         });
         if (ctx.newComments.length > 0) {
             await deps.tracker.removeProperty(item, CHANGES_REQUESTED_LABEL);
+            const beflowOwnsPr =
+                record?.jobKind === "implement" && resolvePr(config, registry, projectKey).owner === "beflow";
             await runIssue(item.key, AUTONOMOUS_DISPATCH, {
                 ...runIssueDeps(deps, config, registry, log),
-                continuation: renderContinuation(deps.prompts, ctx),
+                continuation: renderContinuation(deps.prompts, ctx, beflowOwnsPr),
             });
             log(`beflow: watch ${projectKey} — rework ${item.key}`);
             return { action: "rework", key: item.key };
@@ -456,8 +459,13 @@ export async function watchTick(projectKey: string, deps: WatchDeps): Promise<Wa
             }
 
             const ctx = await assembleContinuation(deps.tracker, item, { record, since: record.updatedAt });
-            const ciNote = `The CI checks on this PR are failing (${checks.failing.join(", ") || "unknown checks"}). Investigate the failures, fix them, and update the existing PR (${record.prUrl}). Then emit the report block.`;
-            const continuation = `${ciNote}\n\n${renderContinuation(deps.prompts, ctx)}`;
+            const beflowOwnsPr =
+                record.jobKind === "implement" && resolvePr(config, registry, projectKey).owner === "beflow";
+            const failingChecks = checks.failing.join(", ") || "unknown checks";
+            const ciNote = beflowOwnsPr
+                ? `The CI checks on this PR are failing (${failingChecks}). Investigate the failures, fix them, and push your branch (beflow updates the PR). Then emit the report block.`
+                : `The CI checks on this PR are failing (${failingChecks}). Investigate the failures, fix them, and update the existing PR (${record.prUrl}). Then emit the report block.`;
+            const continuation = `${ciNote}\n\n${renderContinuation(deps.prompts, ctx, beflowOwnsPr)}`;
             await runIssue(item.key, AUTONOMOUS_DISPATCH, {
                 ...runIssueDeps(deps, config, registry, log),
                 continuation,
@@ -581,9 +589,11 @@ export async function watchTick(projectKey: string, deps: WatchDeps): Promise<Wa
             if (record?.escalatedAt !== undefined) {
                 await notifyEscalation(deps.notify, item, "resolved", "A human responded; resuming.");
             }
+            const beflowOwnsPr =
+                record?.jobKind === "implement" && resolvePr(config, registry, projectKey).owner === "beflow";
             await runIssue(item.key, AUTONOMOUS_DISPATCH, {
                 ...runIssueDeps(deps, config, registry, log),
-                continuation: renderContinuation(deps.prompts, ctx),
+                continuation: renderContinuation(deps.prompts, ctx, beflowOwnsPr),
             });
             log(`beflow: watch ${projectKey} — answered ${item.key}`);
             return { action: "answered", key: item.key };

package/src/model/types.ts

@@ -33,3 +33,30 @@ export interface Resolved {
     repoPath: string;
     runMode: RunMode;
 }
+
+export type PrOwner = "beflow" | "agent";
+
+export interface ResolvedPr {
+    owner: PrOwner;
+    baseBranch: string;
+}
+
+export type PolicyEvaluator = "globs" | "command" | "agentowners" | "off";
+
+export type PolicyDecision = "block" | "require_approval" | "allow";
+
+export type PolicyOnBlock = "comment";
+
+export interface PolicyRule {
+    paths?: string[];
+    agent?: string;
+    decision: PolicyDecision;
+}
+
+export interface ResolvedPolicy {
+    evaluator: PolicyEvaluator;
+    command?: string[];
+    rules?: PolicyRule[];
+    agentownersPath?: string;
+    onBlock: PolicyOnBlock;
+}

package/src/prompts/defaults/continuation.md

@@ -6,4 +6,4 @@ Open PR: {{pr_url}}
 New input since your last update:
 {{review_comments}}
 
-Address the input above. If a pull request is already open for this item, UPDATE it — do not open a new one. Then finish the work and emit your report block as usual.
+{{pr_continuation_instruction}} Then finish the work and emit your report block as usual.

package/src/prompts/defaults/implement.md

@@ -6,8 +6,8 @@ Work through it:
 - Read and obey that repo's CLAUDE.md — it carries the architecture, conventions, and Definition of Done. The repo holds the bar; follow its existing patterns for structure, naming, error handling, and tests.
 - Make the change, and back EVERY behavioral change with a test. New behavior without a test does not count as done.
 - Run the repo's own test and lint commands and paste their REAL output into the report `summary`/`notes`. Fabricating or paraphrasing results is forbidden — paste what actually ran.
-- ONLY when the gate is green — tests and lint pass on real output — and every item on your to-do list is marked complete (nothing left pending or in progress), commit, push, and open a pull request with `gh`, then put the PR URL in `prUrl`.
+- ONLY when the gate is green — tests and lint pass on real output — and every item on your to-do list is marked complete (nothing left pending or in progress), {{pr_instruction}}
 
 If the task is ambiguous, or turns out far larger than described, STOP: do not guess and do not half-do it. Return status `needs_input` with the specific decisions you need in `questions`.
 
-When you are continuing a returning item (a continuation block precedes this task), read the prior PR and the new input, address it, and UPDATE the existing pull request — do not open a new one.
+When you are continuing a returning item (a continuation block precedes this task), read the prior PR and the new input, address it, and {{pr_continuation_instruction}}

package/src/resolve/precedence.ts

@@ -1,5 +1,5 @@
-import type { Project } from "../config/schema.ts";
-import type { IssueMeta, JobKind, Resolved, RunMode, StateGroup } from "../model/types.ts";
+import type { Config, Project, Registry } from "../config/schema.ts";
+import type { IssueMeta, JobKind, ResolvedPolicy, ResolvedPr, Resolved, RunMode, StateGroup } from "../model/types.ts";
 import { autoDetectJobKind } from "./jobkind.ts";
 
 export interface ResolveInputs {
@@ -7,7 +7,7 @@ export interface ResolveInputs {
     meta: IssueMeta;
     project: Project;
     // Optional because the resolver is defensive: if nothing global is set it
-    // falls through to the built-in. (In practice config.defaults always fills these.)
+    // falls through to the built-in. (In practice config always fills these.)
     global: {
         agent?: string;
         routing?: { implement?: string; spec?: string; triage?: string };
@@ -39,7 +39,7 @@ export function resolveAgent(inputs: ResolveInputs, jobKind: JobKind): string {
             inputs.meta.agent,
             inputs.project.routing?.[jobKind],
             inputs.global.routing?.[jobKind],
-            inputs.project.defaults?.agent,
+            inputs.project.agent,
             inputs.global.agent,
         ) ?? AGENT_BUILTIN
     );
@@ -47,7 +47,7 @@ export function resolveAgent(inputs: ResolveInputs, jobKind: JobKind): string {
 
 export function resolveRunMode(inputs: ResolveInputs): RunMode {
     return (
-        cascade(inputs.cli.runMode, inputs.meta.runMode, inputs.project.defaults?.runMode, inputs.global.runMode) ??
+        cascade(inputs.cli.runMode, inputs.meta.runMode, inputs.project.runMode, inputs.global.runMode) ??
         RUN_MODE_BUILTIN
     );
 }
@@ -91,6 +91,41 @@ export function resolveJobKind(inputs: ResolveInputs): JobKind {
     );
 }
 
+const PR_OWNER_BUILTIN: ResolvedPr["owner"] = "agent";
+const PR_BASE_BRANCH_BUILTIN = "auto";
+const POLICY_EVALUATOR_BUILTIN: ResolvedPolicy["evaluator"] = "off";
+const POLICY_ON_BLOCK_BUILTIN: ResolvedPolicy["onBlock"] = "comment";
+
+/**
+ * Project-over-default resolution of PR mechanics. A present `projects.<KEY>.pr`
+ * replaces the top-level `pr` wholesale (no field merge); the built-in defaults
+ * (`agent` / `auto`) then fill any field the chosen block leaves unset.
+ */
+export function resolvePr(config: Config, registry: Registry, projectKey: string): ResolvedPr {
+    const block = registry.projects[projectKey]?.pr ?? config.pr;
+    return {
+        owner: block?.owner ?? PR_OWNER_BUILTIN,
+        baseBranch: block?.baseBranch ?? PR_BASE_BRANCH_BUILTIN,
+    };
+}
+
+/**
+ * Project-over-default resolution of the post-run policy gate. A present
+ * `projects.<KEY>.policy` replaces the top-level `policy` wholesale (no field
+ * merge); the built-in defaults (evaluator `off`, onBlock `comment`) then fill
+ * any field the chosen block leaves unset.
+ */
+export function resolvePolicy(config: Config, registry: Registry, projectKey: string): ResolvedPolicy {
+    const block = registry.projects[projectKey]?.policy ?? config.policy;
+    return {
+        evaluator: block?.evaluator ?? POLICY_EVALUATOR_BUILTIN,
+        command: block?.command,
+        rules: block?.rules,
+        agentownersPath: block?.agentownersPath,
+        onBlock: block?.onBlock ?? POLICY_ON_BLOCK_BUILTIN,
+    };
+}
+
 export function resolve(inputs: ResolveInputs): Resolved {
     const { repo, repoPath } = resolveRepo(inputs);
     const jobKind = resolveJobKind(inputs);