ai-foreman 1.7.20 → 1.7.22

package/dist/adapters/recovering.js

@@ -10,15 +10,21 @@ export class RecoveringAdapter {
     eventQueue = new AsyncQueue();
     eventPump;
     closed = false;
+    contractEnforcing = false;
     constructor(opts) {
         this.opts = opts;
         this.adapter = opts.initial;
         this.runtime = opts.runtime;
         this.eventPump = this.forwardEvents(this.adapter);
     }
+    graphRuntimeSettings() { return this.adapter.graphRuntimeSettings?.(); }
     get agent() {
         return this.adapter.agent;
     }
+    contractCapabilities() { return this.adapter.contractCapabilities?.() ?? { sameSessionAcceptance: false, nativeCompactionBarrier: false }; }
+    enableContractEnforcement() { this.contractEnforcing = true; this.adapter.enableContractEnforcement?.(); }
+    contractCompactionSequence() { return this.adapter.contractCompactionSequence?.() ?? 0; }
+    acceptContractDelivery(sequence) { this.adapter.acceptContractDelivery?.(sequence); }
     async sendTurn(text, policy) {
         while (true) {
             const result = await this.adapter.sendTurn(text, policy);
@@ -37,6 +43,10 @@ export class RecoveringAdapter {
             // instruction. Never replay it or silently switch providers.
             if (result.failure.category === "session-unavailable" || result.failure.dispatchState === "unknown")
                 return result;
+            // A replacement has new host-side barriers, even when it resumes the
+            // same native session. Only the shared build gate can renew acceptance.
+            if (this.contractEnforcing)
+                return { ...result, text: `${result.text}\nContract-enforcing runtime recovery requires an explicit host resume through the shared preparation/delivery gate; this turn was not replayed.` };
             const otherRuntime = this.runtime === "claude" ? "codex" : "claude";
             const choice = this.opts.choose
                 ? await this.opts.choose(result, this.runtime, otherRuntime)

package/dist/adapters/types.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderTurnPurpose } from "../providerPhase.js";
 /**
  * Agent-agnostic interface over a coding agent ("builder").
  */
@@ -233,6 +234,11 @@ export interface BuilderAdapterOptions {
     fast?: boolean;
     /** Codex sandbox mode. Defaults to workspace-write for implementation runs. */
     sandboxMode?: "workspace-write" | "read-only";
+    /** Explicit opt-in to per-command sandbox escalation. QA remains offline/never. */
+    approvalPolicy?: "never" | "on-request";
+    approvalTimeoutMs?: number;
+    /** Build-scoped explicit grant; ignored for read-only/QA roles. */
+    networkAccess?: boolean;
     /** Role system text to append to the harness system prompt (from .rafi/compiled or library). */
     systemPromptAppend?: string;
     /** Skill names to preload for this session (Claude: lazy-loaded; Codex: flattened). */
@@ -273,12 +279,21 @@ export interface BuilderAdapterOptions {
     }) => void;
 }
 export interface BuilderAdapter {
+    graphRuntimeSettings?(): Pick<BuilderAdapterOptions, "model" | "effort" | "fast" | "runtimeExecutable"> | undefined;
     readonly agent: "claude" | "codex";
+    contractCapabilities?(): {
+        sameSessionAcceptance: boolean;
+        nativeCompactionBarrier: boolean;
+    };
+    enableContractEnforcement?(): void;
+    contractCompactionSequence?(): number;
+    acceptContractDelivery?(sequence: number): void;
     /** Send one instruction; resolves when that turn completes. */
     sendTurn(text: string, policy?: {
         handback?: boolean;
         responseOnly?: boolean;
         logicalActionId?: string;
+        purpose?: ProviderTurnPurpose;
     }): Promise<TurnResult>;
     /** Synchronous observation through the event owner. Terminal precedes sendTurn resolution. */
     observeEvents?(listener: (event: BuilderEvent) => void): () => void;

package/dist/agentRun.d.ts

@@ -1,3 +1,4 @@
+export { withGraphDerivedAccess } from "./graph/derived.js";
 import { type PermissionConfig } from "./config.js";
 import { Log } from "./log.js";
 import { type StepStatus } from "./foreman.js";
@@ -6,10 +7,13 @@ import type { AnsweredProviderQuestion } from "./providerQuestions.js";
 import { type RoleBundle } from "./roles.js";
 import type { AgentRuntime } from "./runtimeAuth.js";
 import type { AgentRoleDefaultsV1, ProviderSessionRefV1 } from "rafi-spec";
+import type { GraphPurpose } from "rafi-spec";
 export type { EffortLevel } from "./adapters/types.js";
 export declare const VALID_EFFORT: readonly EffortLevel[];
 export interface RoleBuilderOptions {
+    graphPurpose?: GraphPurpose;
     projectDir: string;
+    configRoot?: string;
     role: string;
     agent?: string;
     model?: string;
@@ -21,6 +25,7 @@ export interface RoleBuilderOptions {
     log?: Log;
     permissionConfig?: PermissionConfig;
     extraSkills?: string[];
+    preloadedSkillContent?: BuilderAdapterOptions["preloadedSkillContent"];
     sandboxMode?: BuilderAdapterOptions["sandboxMode"];
     /** Disable recovery-session persistence for isolated, non-recoverable roles such as Manager. */
     persistSessionBindings?: boolean;
@@ -33,6 +38,7 @@ export interface RoleBuilderOptions {
     onProviderQuestion?: (request: import("./adapters/types.js").PermissionRequest) => void;
 }
 export interface RoleBuilder {
+    graphRoot?: string;
     builder: BuilderAdapter;
     runtime: AgentRuntime;
     model?: string;
@@ -65,5 +71,6 @@ export declare function makeLogPath(projectDir: string, label: string): string;
 export declare function mergeSkills(roleSkills: readonly string[], extraSkills?: readonly string[]): string[];
 export declare function readOnlyPermissionConfig(): PermissionConfig;
 export declare function createRoleBuilder(opts: RoleBuilderOptions): Promise<RoleBuilder>;
+export declare function sendRoleGraphTurn(role: RoleBuilder, instruction: string, purpose: GraphPurpose, policy?: Parameters<BuilderAdapter["sendTurn"]>[1]): Promise<TurnResult>;
 export declare function readRoleDefaultsForExecution(projectDir: string, role: string): AgentRoleDefaultsV1 | undefined;
 export declare function runRoleInstruction(opts: RoleInstructionRunOptions): Promise<RoleInstructionRunResult>;

package/dist/agentRun.js

@@ -1,3 +1,4 @@
+export { withGraphDerivedAccess } from "./graph/derived.js";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig, DEFAULT_CONFIG } from "./config.js";
@@ -15,6 +16,7 @@ import { resolveAgentForProject } from "./cli/runtimeSelection.js";
 import { parse as parseYaml } from "yaml";
 import { captureWorkspaceIdentity, createProviderSessionRef, resolveUniqueSessionBinding } from "./sessionIdentity.js";
 import { WorkflowDb } from "./workflowDb.js";
+import { graphContext, sendGraphTurn } from "./graph/turn.js";
 export const VALID_EFFORT = ["low", "medium", "high", "xhigh"];
 export function assertEffortLevel(effort) {
     if (effort && !VALID_EFFORT.includes(effort)) {
@@ -107,13 +109,14 @@ export async function createRoleBuilder(opts) {
     if (!existsSync(opts.projectDir)) {
         throw new Error(`project directory not found: ${opts.projectDir}`);
     }
-    const saved = readRoleDefaultsForExecution(opts.projectDir, opts.role);
+    const executionRoot = opts.configRoot ?? opts.projectDir;
+    const saved = readRoleDefaultsForExecution(executionRoot, opts.role);
     if (opts.resumeSessionRef && opts.resumeSessionId && opts.resumeSessionRef.sessionId !== opts.resumeSessionId) {
         throw new Error("resume session ID does not match the supplied location-scoped reference");
     }
     let requestedResumeRef = opts.resumeSessionRef;
     if (!requestedResumeRef && opts.resumeSessionId) {
-        const bindingDb = new WorkflowDb(opts.projectDir);
+        const bindingDb = new WorkflowDb(executionRoot);
         try {
             requestedResumeRef = resolveUniqueSessionBinding(bindingDb.providerSessionBindings(opts.resumeSessionId), opts.resumeSessionId);
         }
@@ -124,19 +127,19 @@ export async function createRoleBuilder(opts) {
     const configuredEffort = saved?.reasoning && saved.reasoning !== "default" ? saved.reasoning : undefined;
     const effectiveEffort = opts.effort ?? (VALID_EFFORT.includes(configuredEffort) ? configuredEffort : undefined);
     assertEffortLevel(effectiveEffort);
-    let runtime = resolveAgentForProject(opts.projectDir, opts.agent ?? requestedResumeRef?.provider ?? saved?.make);
+    let runtime = resolveAgentForProject(executionRoot, opts.agent ?? requestedResumeRef?.provider ?? saved?.make);
     if (requestedResumeRef && requestedResumeRef.provider !== runtime) {
         throw new Error(`session ${requestedResumeRef.sessionId} belongs to ${requestedResumeRef.provider}, but ${runtime} was selected`);
     }
     if (requestedResumeRef && requestedResumeRef.role !== configurableRole(opts.role)) {
         throw new Error(`session ${requestedResumeRef.sessionId} belongs to role ${requestedResumeRef.role}, not ${configurableRole(opts.role)}`);
     }
-    const config = loadConfig(join(opts.projectDir, "foreman.yaml"));
-    const log = opts.log ?? new Log(makeLogPath(opts.projectDir, opts.label.replace(/\s+/g, "-")));
-    const roleBundle = loadRoleBundle(opts.role, { projectDir: opts.projectDir });
+    const config = loadConfig(join(executionRoot, "foreman.yaml"));
+    const log = opts.log ?? new Log(makeLogPath(executionRoot, opts.label.replace(/\s+/g, "-")));
+    const roleBundle = loadRoleBundle(opts.role, { projectDir: opts.configRoot ?? opts.projectDir });
     const initialModel = opts.model ?? (saved?.model !== "default" ? saved?.model : undefined) ?? roleBundle.model ?? undefined;
     const effort = effectiveEffort ?? roleBundle.effort ?? undefined;
-    const ready = await ensureRuntimeReadyForCommand(opts.projectDir, runtime, {
+    const ready = await ensureRuntimeReadyForCommand(executionRoot, runtime, {
         label: opts.label,
         yes: Boolean(opts.yes),
         allowSwitch: requestedResumeRef || opts.resumeSessionId ? false : opts.allowSwitch,
@@ -151,7 +154,7 @@ export async function createRoleBuilder(opts) {
     const makeAdapter = async (nextRuntime, resumeSessionId, resumeSessionRef) => {
         let scopedRef = resumeSessionRef;
         if (!scopedRef && resumeSessionId) {
-            const bindingDb = new WorkflowDb(opts.projectDir);
+            const bindingDb = new WorkflowDb(executionRoot);
             try {
                 scopedRef = resolveUniqueSessionBinding(bindingDb.providerSessionBindings(resumeSessionId), resumeSessionId);
             }
@@ -165,7 +168,7 @@ export async function createRoleBuilder(opts) {
                 stream: opts.role,
                 generation: 0,
                 cwd: opts.projectDir,
-                configRoot: opts.projectDir,
+                configRoot: opts.configRoot ?? opts.projectDir,
                 workspaceIdentity: captureWorkspaceIdentity(opts.projectDir),
                 source: "legacy-inferred",
             });
@@ -175,7 +178,7 @@ export async function createRoleBuilder(opts) {
         }
         const adapterOpts = {
             cwd: opts.projectDir,
-            configRoot: opts.projectDir,
+            configRoot: opts.configRoot ?? opts.projectDir,
             runtimeExecutable,
             runtimePhase: phaseForRole(opts.role),
             onQuestionTrace: (trace) => log.write("question-round-trip", { ...trace }),
@@ -196,6 +199,7 @@ export async function createRoleBuilder(opts) {
             sandboxMode: opts.sandboxMode,
             systemPromptAppend: roleBundle.system || undefined,
             skills: skills.length > 0 ? skills : undefined,
+            preloadedSkillContent: opts.preloadedSkillContent,
         };
         const adapter = nextRuntime === "codex"
             ? new CodexAdapter(adapterOpts)
@@ -221,7 +225,7 @@ export async function createRoleBuilder(opts) {
     const persistSessionRef = (ref) => {
         if (opts.persistSessionBindings === false)
             return;
-        const bindingDb = new WorkflowDb(opts.projectDir);
+        const bindingDb = new WorkflowDb(executionRoot);
         try {
             bindingDb.recordProviderSessionBinding(ref);
         }
@@ -239,7 +243,7 @@ export async function createRoleBuilder(opts) {
         enabled: interactive,
         allowSwitch: opts.allowSwitch !== false && !opts.resumeSessionId && !requestedResumeRef,
         recreate: async (nextRuntime, resumeSessionId, resumeSessionRef) => {
-            const nextReady = await ensureRuntimeReadyForCommand(opts.projectDir, nextRuntime, {
+            const nextReady = await ensureRuntimeReadyForCommand(executionRoot, nextRuntime, {
                 label: opts.label,
                 allowSwitch: false,
                 model: nextRuntime === runtime ? model : undefined,
@@ -251,7 +255,13 @@ export async function createRoleBuilder(opts) {
         },
         onSessionRef: persistSessionRef,
     });
-    return { builder, runtime, model, effort, roleBundle, skills, log };
+    return { builder, runtime, model, effort, roleBundle, skills, log, graphRoot: opts.configRoot ?? opts.projectDir };
+}
+export function sendRoleGraphTurn(role, instruction, purpose, policy) {
+    const root = role.graphRoot;
+    if (!root)
+        return role.builder.sendTurn(instruction, policy);
+    return sendGraphTurn(role.builder, instruction, graphContext(root, role.builder.sessionRef?.()?.cwd ?? root, purpose, instruction), policy);
 }
 function phaseForRole(role) {
     if (role === "planner")
@@ -322,6 +332,7 @@ export async function runRoleInstruction(opts) {
     const viewer = printEvents(builder.events());
     const config = loadConfig(join(opts.projectDir, "foreman.yaml"));
     const foreman = new Foreman(builder, log, { desktop: config.notifications.enabled, terminalBell: config.notifications.terminal_bell }, false, 3, opts.projectDir);
+    foreman.setGraphPurpose(opts.graphPurpose ?? { planner: "planning", discovery: "discovery", "ticket-maker": "ticket-population", uninstaller: "uninstall-analysis" }[opts.role] ?? "implementation");
     try {
         const turn = await foreman.runInstruction(opts.instruction);
         await builder.close();

package/dist/branch/currentGuard.d.ts

@@ -34,6 +34,7 @@ export declare class CurrentWorkflowGuardAdapter implements BuilderAdapter {
     restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
+    graphRuntimeSettings(): Pick<import("../adapters/types.js").BuilderAdapterOptions, "model" | "effort" | "fast" | "runtimeExecutable"> | undefined;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;
     events(): AsyncIterable<BuilderEvent>;

package/dist/branch/currentGuard.js

@@ -63,6 +63,7 @@ export class CurrentWorkflowGuardAdapter {
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
+    graphRuntimeSettings() { return this.adapter.graphRuntimeSettings?.(); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     switchSettings(settings) { return this.adapter.switchSettings?.(settings) ?? Promise.resolve({ ok: false, error: "settings switch unavailable" }); }
     events() { return this.adapter.events(); }

package/dist/branch/dirtyBaseline.d.ts

@@ -0,0 +1,5 @@
+/** Capture build input with a private index. Never stash, commit, or modify the user's index. */
+export declare function captureDirtyBaseline(projectDir: string, mode: "preserve" | "include"): {
+    base: string;
+    recordPath: string;
+};

package/dist/branch/dirtyBaseline.js

@@ -0,0 +1,69 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+/** Capture build input with a private index. Never stash, commit, or modify the user's index. */
+export function captureDirtyBaseline(projectDir, mode) {
+    const git = (args, env = process.env) => execFileSync("git", args, { cwd: projectDir, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    if (git(["diff", "--name-only", "--diff-filter=U"]))
+        throw new Error("Resolve Git conflicts before starting an isolated build; Rafi has preserved your files.");
+    const head = () => { try {
+        return git(["rev-parse", "--verify", "HEAD"]);
+    }
+    catch {
+        return undefined;
+    } };
+    const parent = head();
+    if (!parent && mode === "preserve")
+        throw new Error("This repository has no committed baseline. Use --dirty-work include to capture current files privately, or make an initial commit first.");
+    const directory = join(projectDir, ".foreman/dirty-baselines");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const recordPath = mkdtempSync(join(directory, "baseline-"));
+    const indexPath = resolve(projectDir, git(["rev-parse", "--git-path", "index"]));
+    const indexDigest = existsSync(indexPath) ? createHash("sha256").update(readFileSync(indexPath)).digest("hex") : null;
+    const status = git(["status", "--porcelain", "--untracked-files=all"]);
+    const paths = execFileSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: projectDir }).toString().split("\0").filter(path => path && !path.startsWith(".foreman/") && !/^\.rafi\/(recovery|observability)\.sqlite3/.test(path));
+    // HEAD paths are needed too: staged deletions/rename sources no longer exist in the user's index.
+    if (parent)
+        paths.push(...execFileSync("git", ["ls-tree", "-r", "--name-only", "-z", parent], { cwd: projectDir }).toString().split("\0").filter(path => path && !path.startsWith(".foreman/") && !/^\.rafi\/(recovery|observability)\.sqlite3/.test(path)));
+    const files = [...new Set(paths)].map(path => {
+        const absolute = join(projectDir, path);
+        if (!existsSync(absolute))
+            return { path, digest: null };
+        const stat = lstatSync(absolute);
+        if (stat.isDirectory()) {
+            if (mode === "include" && execFileSync("git", ["status", "--porcelain"], { cwd: absolute, encoding: "utf8" }).trim())
+                throw new Error(`Dirty submodule ${path} cannot be included automatically. Commit its work or use --dirty-work preserve.`);
+            return { path, digest: null, kind: "submodule" };
+        }
+        return { path, digest: createHash("sha256").update(stat.isSymbolicLink() ? readlinkSync(absolute) : readFileSync(absolute)).digest("hex"), mode: stat.mode, kind: stat.isSymbolicLink() ? "symlink" : "file" };
+    });
+    const diffBase = parent ?? execFileSync("git", ["hash-object", "-w", "-t", "tree", "--stdin"], { cwd: projectDir, input: "", encoding: "utf8" }).trim();
+    const diff = execFileSync("git", ["diff", diffBase, "--binary"], { cwd: projectDir });
+    writeFileSync(join(recordPath, "working.patch"), diff, { mode: 0o600 });
+    let base = parent;
+    if (mode === "include") {
+        const env = { ...process.env, GIT_INDEX_FILE: join(recordPath, "index"), GIT_AUTHOR_NAME: "Rafi baseline", GIT_AUTHOR_EMAIL: "baseline@rafi.local", GIT_COMMITTER_NAME: "Rafi baseline", GIT_COMMITTER_EMAIL: "baseline@rafi.local" };
+        git(parent ? ["read-tree", parent] : ["read-tree", "--empty"], env);
+        if (paths.length)
+            execFileSync("git", ["add", "-A", "--pathspec-from-file=-", "--pathspec-file-nul"], { cwd: projectDir, env: { ...env, GIT_LITERAL_PATHSPECS: "1" }, input: `${paths.join("\0")}\0`, stdio: ["pipe", "pipe", "pipe"] });
+        const tree = git(["write-tree"], env);
+        base = git(["commit-tree", tree, ...(parent ? ["-p", parent] : []), "-m", "Rafi preserved dirty build input"], env);
+    }
+    const finalIndexDigest = existsSync(indexPath) ? createHash("sha256").update(readFileSync(indexPath)).digest("hex") : null;
+    const changed = head() !== parent || finalIndexDigest !== indexDigest || files.some(file => {
+        if (file.kind === "submodule")
+            return false;
+        const absolute = join(projectDir, file.path);
+        if (!existsSync(absolute))
+            return file.digest !== null;
+        if (file.digest === null)
+            return true;
+        const stat = lstatSync(absolute);
+        return createHash("sha256").update(stat.isSymbolicLink() ? readlinkSync(absolute) : readFileSync(absolute)).digest("hex") !== file.digest || stat.mode !== file.mode;
+    });
+    if (changed)
+        throw new Error("Checkout or index changed while capturing the baseline. Your work is preserved; retry after those edits finish.");
+    writeFileSync(join(recordPath, "manifest.json"), JSON.stringify({ version: 1, mode, parent, base, indexDigest, status, files, patchDigest: createHash("sha256").update(diff).digest("hex"), createdAt: new Date().toISOString(), delivery: "isolated branches; no automatic merge into dirty checkout" }, null, 2), { mode: 0o600 });
+    return { base, recordPath };
+}

package/dist/branch/finalization.js

@@ -1,3 +1,4 @@
+import { graphCheckoutBoundary } from "./git.js";
 import { currentWorktreeBranch, findWorktreeForBranch, hasWorktreeChanges, mergeBranchToLocalBase, runGit } from "./git.js";
 import { captureProspectiveGitTree } from "../qaSnapshot.js";
 export class DirectMergeSourceChangedError extends Error {
@@ -75,6 +76,7 @@ export function removeDirectMergeWorktree(projectDir, intent, worktree) {
     verifyDirectMergeWorktree(projectDir, intent);
     // Let Git reject edits made even after the preceding verification. Never
     // force-remove or recursively delete a finalization worktree on failure.
+    graphCheckoutBoundary(projectDir, worktree, "worktree-removed");
     runGit(projectDir, ["worktree", "remove", worktree]);
 }
 export function hasExactStagedDirectMerge(projectDir, intent) {
@@ -95,8 +97,10 @@ export function hasExactStagedDirectMerge(projectDir, intent) {
 }
 export function executeDirectMerge(projectDir, intent, message) {
     const completed = reconcileDirectMerge(projectDir, intent);
-    if (completed)
+    if (completed) {
+        graphCheckoutBoundary(projectDir, projectDir, "merge-or-rebase");
         return completed;
+    }
     verifyDirectMergeWorktree(projectDir, intent);
     const indexTree = runGit(projectDir, ["write-tree"]).stdout;
     const baseTree = runGit(projectDir, ["rev-parse", `${intent.baseCommit}^{tree}`]).stdout;
@@ -107,6 +111,7 @@ export function executeDirectMerge(projectDir, intent, message) {
         // Git prepared the merge before the host crashed, but commit did not.
         // Only commit the exact tree frozen in the durable intent.
         runGit(projectDir, ["commit", "-m", message]);
+        graphCheckoutBoundary(projectDir, projectDir, "merge-or-rebase");
     }
     else {
         // Squash/merge publish the immutable source commit, even if an external

package/dist/branch/git.d.ts

@@ -16,6 +16,7 @@ export declare function ensureCleanBaseWorktree(cwd: string, opts?: BaseWorktree
 export declare function ensureForemanExcluded(cwd: string): void;
 export declare function createTicketWorktree(projectDir: string, runId: string, branch: string, base: string): string;
 export declare function findWorktreeForBranch(projectDir: string, branch: string): string | undefined;
+export declare function graphCheckoutBoundary(projectDir: string, workspace: string, reason: "merge-or-rebase" | "worktree-created" | "worktree-removed"): void;
 export declare function removeTicketWorktree(projectDir: string, worktreePath: string): void;
 export declare function currentWorktreeBranch(worktreePath: string): string;
 export declare function hasTrackerChanges(worktreePath: string, paths?: {

package/dist/branch/git.js

@@ -1,3 +1,4 @@
+import { invalidateGraphWorkspace } from "../graph/lifecycle.js";
 import { execFileSync } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -52,6 +53,7 @@ export function createTicketWorktree(projectDir, runId, branch, base) {
     const worktreePath = join(projectDir, ".foreman", "worktrees", runId, branch.replace(/\//g, "__"));
     mkdirSync(dirname(worktreePath), { recursive: true });
     runGit(projectDir, ["worktree", "add", "-b", branch, worktreePath, base]);
+    graphCheckoutBoundary(projectDir, worktreePath, "worktree-created");
     return worktreePath;
 }
 export function findWorktreeForBranch(projectDir, branch) {
@@ -67,7 +69,16 @@ export function findWorktreeForBranch(projectDir, branch) {
     }
     return undefined;
 }
+export function graphCheckoutBoundary(projectDir, workspace, reason) {
+    try {
+        invalidateGraphWorkspace(projectDir, workspace, reason);
+    }
+    catch (error) {
+        console.error(`rafi graph: checkout metadata invalidation failed: ${String(error)}`);
+    }
+}
 export function removeTicketWorktree(projectDir, worktreePath) {
+    graphCheckoutBoundary(projectDir, worktreePath, "worktree-removed");
     try {
         runGit(projectDir, ["worktree", "remove", "--force", worktreePath]);
     }
@@ -120,8 +131,10 @@ export function pushBranch(worktreePath, branch) {
 export function mergeBranchToLocalBase(projectDir, branch, baseBranch, message, method = "squash") {
     if (method === "rebase") {
         const branchWorktree = findWorktreeForBranch(projectDir, branch);
-        if (branchWorktree)
+        if (branchWorktree) {
             runGit(branchWorktree, ["rebase", baseBranch]);
+            graphCheckoutBoundary(projectDir, branchWorktree, "merge-or-rebase");
+        }
         else
             runGit(projectDir, ["rebase", baseBranch, branch]);
     }
@@ -140,6 +153,7 @@ export function mergeBranchToLocalBase(projectDir, branch, baseBranch, message,
     else {
         runGit(projectDir, ["merge", "--ff-only", branch]);
     }
+    graphCheckoutBoundary(projectDir, projectDir, "merge-or-rebase");
     return runGit(projectDir, ["rev-parse", "--short", "HEAD"]).stdout;
 }
 /** Compatibility export for callers compiled against the older helper. */

package/dist/branch/resume.js

@@ -73,7 +73,7 @@ export function findResumableBranchSessions(foremanDir) {
 }
 export function formatBranchContinueCommand(projectDir, session) {
     const args = [
-        "ai-foreman",
+        "rafi",
         "start",
         shellQuote(projectDir),
         "--steps",
@@ -91,7 +91,7 @@ export function formatBranchContinueCommand(projectDir, session) {
         args.push("--model", shellQuote(session.model));
     if (session.effort)
         args.push("--effort", shellQuote(session.effort));
-    if (session.reviewProvider)
+    if (session.reviewProvider && session.completionMode !== "none" && (session.completionMode || session.createPr))
         args.push("--provider", shellQuote(session.reviewProvider));
     if (session.fast)
         args.push("--fast");

package/dist/branch/runner.d.ts

@@ -79,8 +79,10 @@ export declare function runBranchPlan(opts: BranchRunnerOptions): Promise<Branch
 export declare function buildBranchTicketInstruction(node: BranchPlanNode, trackerPaths?: {
     progressDoc?: string;
     archiveDoc?: string;
+    validationChecklist?: string[];
 }): string;
 export declare function buildBranchTicketResumeInstruction(node: BranchPlanNode, trackerPaths?: {
     progressDoc?: string;
     archiveDoc?: string;
+    validationChecklist?: string[];
 }): string;