ai-foreman 1.7.7 → 1.7.9

package/dist/adapters/claude.d.ts

@@ -1,7 +1,7 @@
 import type { SDKSessionInfo, PermissionResult } from "@anthropic-ai/claude-agent-sdk";
 /** Lazy-load the Claude Agent SDK. Throws an actionable error if not installed. */
 export declare function requireClaudeSDK(): Promise<typeof import("@anthropic-ai/claude-agent-sdk")>;
-import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, PermissionDecision, ProviderSettingSwitch, ProviderSessionUsage, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, NativeCompaction, CompactResult, ContextUsage, PermissionDecision, ProviderSettingSwitch, ProviderSessionUsage, TurnResult } from "./types.js";
 import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 /**
  * Pure function: build the `options` object passed to `query()`.
@@ -55,6 +55,11 @@ export declare class ClaudeAdapter implements BuilderAdapter {
     private structuredError?;
     private apiErrorStatus?;
     private compactResult?;
+    private autoCompactionPrepared;
+    private preparedAutoCompactThreshold?;
+    private manualCompactionInFlight;
+    private nativeCompactions;
+    private nativeCompactionSequence;
     private cumulativeUsage;
     private pending?;
     private terminalResult?;
@@ -73,6 +78,9 @@ export declare class ClaudeAdapter implements BuilderAdapter {
     adoptSessionRef(ref: ProviderSessionRefV1): void;
     validateSession(): Promise<SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<void>;
+    drainNativeCompactions(): NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;

package/dist/adapters/claude.js

@@ -152,6 +152,11 @@ export class ClaudeAdapter {
     structuredError;
     apiErrorStatus;
     compactResult;
+    autoCompactionPrepared = false;
+    preparedAutoCompactThreshold;
+    manualCompactionInFlight = false;
+    nativeCompactions = [];
+    nativeCompactionSequence = 0;
     cumulativeUsage = { observedAt: new Date(0).toISOString(), source: "provider" };
     pending;
     terminalResult;
@@ -292,6 +297,8 @@ export class ClaudeAdapter {
             if (msg.compact_result === "success") {
                 this.compactResult = { ok: true };
                 this.eventQueue.push({ kind: "session-transition", transition: "compacted" });
+                if (!this.manualCompactionInFlight)
+                    this.nativeCompactions.push({ id: `claude:${this._sessionId ?? "unknown"}:${++this.nativeCompactionSequence}`, occurredAt: new Date().toISOString(), provider: "claude" });
             }
             else if (msg.compact_result === "failed") {
                 this.compactResult = { ok: false, error: sanitizeDiagnostics(msg.compact_error ?? "Claude native compaction failed") };
@@ -423,7 +430,14 @@ export class ClaudeAdapter {
     }
     async compact() {
         this.compactResult = undefined;
-        const result = await this.sendTurn("/compact");
+        this.manualCompactionInFlight = true;
+        let result;
+        try {
+            result = await this.sendTurn("/compact");
+        }
+        finally {
+            this.manualCompactionInFlight = false;
+        }
         if (result.failure?.category === "session-unavailable") {
             return { ok: false, error: result.text || result.failure.diagnostics, failure: result.failure };
         }
@@ -431,6 +445,43 @@ export class ClaudeAdapter {
             return this.compactResult;
         return { ok: false, error: sanitizeDiagnostics(result.text || "Claude did not emit an explicit compact status") };
     }
+    async prepareAutoCompaction(thresholdPercent = this.opts.autoCompactThresholdPercent) {
+        if (thresholdPercent === undefined)
+            return;
+        const threshold = validThreshold(thresholdPercent);
+        if (this.autoCompactionPrepared && this.preparedAutoCompactThreshold === threshold)
+            return;
+        this.opts.autoCompactThresholdPercent = threshold;
+        await this.query.initializationResult();
+        await this.query.applyFlagSettings({ autoCompactEnabled: true });
+        const baseline = await this.query.getContextUsage();
+        if (!Number.isFinite(baseline.maxTokens) || baseline.maxTokens <= 0
+            || !Number.isFinite(baseline.autoCompactThreshold) || baseline.autoCompactThreshold === undefined
+            || !baseline.isAutoCompactEnabled) {
+            throw new Error("Claude did not expose an enabled native automatic-compaction threshold");
+        }
+        // Claude's setting is the total window. Preserve the provider's own
+        // response/compaction reserve, so the resulting used-token trigger is at
+        // or before Rafi's configured percentage.
+        const reserve = baseline.maxTokens - baseline.autoCompactThreshold;
+        if (reserve < 0)
+            throw new Error("Claude reported an invalid automatic-compaction reserve");
+        const requestedWindow = tokenLimit(baseline.maxTokens, threshold) + reserve;
+        await this.query.applyFlagSettings({ autoCompactEnabled: true, autoCompactWindow: requestedWindow });
+        const installed = await this.query.getContextUsage();
+        if (!installed.isAutoCompactEnabled || installed.autoCompactThreshold === undefined
+            || installed.autoCompactThreshold > tokenLimit(baseline.maxTokens, threshold)) {
+            throw new Error("Claude did not accept the requested native automatic-compaction ceiling");
+        }
+        this.autoCompactionPrepared = true;
+        this.preparedAutoCompactThreshold = threshold;
+    }
+    drainNativeCompactions() {
+        const pending = this.nativeCompactions;
+        this.nativeCompactions = [];
+        return pending;
+    }
+    restoreNativeCompactions(compactions) { this.nativeCompactions.unshift(...compactions); }
     async contextUsage() {
         try {
             const usage = await this.query.getContextUsage();
@@ -510,6 +561,14 @@ export class ClaudeAdapter {
     }
 }
 function finiteNumber(value) { const parsed = Number(value); return value !== null && value !== undefined && value !== "" && Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined; }
+function validThreshold(value) {
+    if (!Number.isInteger(value) || value < 1 || value > 99)
+        throw new Error("automatic compaction threshold must be an integer from 1 to 99");
+    return value;
+}
+function tokenLimit(maximum, percentage) {
+    return Math.max(1, Math.floor(maximum * percentage / 100));
+}
 function isMissingClaudeSession(message) {
     return /no conversation found with session id|session .* not found|conversation .* not found/i.test(message);
 }

package/dist/adapters/codex.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
 import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 export interface CodexLineResult {
     events: BuilderEvent[];
@@ -27,6 +27,13 @@ export declare class CodexAdapter implements BuilderAdapter {
     private providerSessionUsage?;
     private lastTurnTokens?;
     private stderr;
+    private nativeAutoCompactTokenLimit?;
+    private autoCompactionPrepared;
+    private preparedAutoCompactThreshold?;
+    private nativeCompactions;
+    private nativeCompactionSequence;
+    private manualCompactionInFlight;
+    private observedToolCalls;
     constructor(opts: BuilderAdapterOptions);
     buildInstruction(instruction: string): string;
     buildAppServerArgs(): string[];
@@ -35,7 +42,11 @@ export declare class CodexAdapter implements BuilderAdapter {
     sendTurn(instruction: string): Promise<TurnResult>;
     private sendTurnInternal;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<void>;
+    drainNativeCompactions(): NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsage(): Promise<ContextUsage | undefined>;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;
     sessionId(): string | undefined;
@@ -52,5 +63,6 @@ export declare class CodexAdapter implements BuilderAdapter {
     private handle;
     private waitFor;
     private disconnect;
+    private restartForAutoCompaction;
     private buildSkillsAppendix;
 }

package/dist/adapters/codex.js

@@ -43,6 +43,13 @@ export class CodexAdapter {
     providerSessionUsage;
     lastTurnTokens;
     stderr = "";
+    nativeAutoCompactTokenLimit;
+    autoCompactionPrepared = false;
+    preparedAutoCompactThreshold;
+    nativeCompactions = [];
+    nativeCompactionSequence = 0;
+    manualCompactionInFlight = false;
+    observedToolCalls = 0;
     constructor(opts) {
         this.opts = opts;
         this._sessionId = opts.resumeSessionRef?.sessionId ?? opts.resumeSessionId;
@@ -52,7 +59,13 @@ export class CodexAdapter {
         return [this.opts.systemPromptAppend, this.buildSkillsAppendix(), instruction]
             .filter((part) => Boolean(part)).join("\n\n");
     }
-    buildAppServerArgs() { return ["app-server", "--listen", "stdio://"]; }
+    buildAppServerArgs() {
+        const args = ["app-server", "--listen", "stdio://"];
+        if (this.nativeAutoCompactTokenLimit !== undefined) {
+            args.push("-c", `model_auto_compact_token_limit=${this.nativeAutoCompactTokenLimit}`, "-c", 'model_auto_compact_token_limit_scope="total"');
+        }
+        return args;
+    }
     /** Deprecated fixture helper. Runtime execution uses only app-server. */
     buildArgs(instruction) {
         const args = ["exec", "--json", "--skip-git-repo-check", "--sandbox", this.opts.sandboxMode ?? "workspace-write", "-C", this.opts.cwd];
@@ -143,11 +156,17 @@ export class CodexAdapter {
                     && this.usageRevision > usageRevision
                     && this.usage !== undefined;
             }, 30_000);
-            await Promise.all([
-                this.request("thread/compact/start", { threadId: this._sessionId }),
-                done,
-                postCompactUsage,
-            ]);
+            this.manualCompactionInFlight = true;
+            try {
+                await Promise.all([
+                    this.request("thread/compact/start", { threadId: this._sessionId }),
+                    done,
+                    postCompactUsage,
+                ]);
+            }
+            finally {
+                this.manualCompactionInFlight = false;
+            }
             this.eventQueue.push({ kind: "session-transition", transition: "compacted" });
             return { ok: true };
         }
@@ -157,7 +176,54 @@ export class CodexAdapter {
             return { ok: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
+    async prepareAutoCompaction(thresholdPercent = this.opts.autoCompactThresholdPercent) {
+        if (thresholdPercent === undefined)
+            return;
+        const threshold = validThreshold(thresholdPercent);
+        if (this.autoCompactionPrepared && this.preparedAutoCompactThreshold === threshold)
+            return;
+        this.opts.autoCompactThresholdPercent = threshold;
+        await this.ensureThread();
+        // Codex reports its model context window in token-usage notifications, not
+        // in thread/start. Establish the otherwise idle thread with a constrained
+        // setup turn, then restart the app server with the provider-native ceiling
+        // before any Builder or QA work is sent.
+        if (!this.usage?.maximum) {
+            const toolsBefore = this.observedToolCalls;
+            const setup = await this.sendTurnInternal("Rafi internal initialization only. Do not call tools or modify files. Reply briefly that the context is ready.");
+            if (setup.isError)
+                throw new Error(`Codex automatic-compaction setup failed: ${setup.text.slice(0, 240)}`);
+            if (this.observedToolCalls !== toolsBefore)
+                throw new Error("Codex automatic-compaction setup unexpectedly called a tool");
+        }
+        const maximum = this.usage?.maximum;
+        if (!maximum || !Number.isFinite(maximum) || maximum <= 0) {
+            throw new Error("Codex did not report a model context window during automatic-compaction setup");
+        }
+        this.nativeAutoCompactTokenLimit = tokenLimit(maximum, threshold);
+        await this.restartForAutoCompaction();
+        await this.ensureThread();
+        this.autoCompactionPrepared = true;
+        this.preparedAutoCompactThreshold = threshold;
+    }
+    drainNativeCompactions() {
+        const pending = this.nativeCompactions;
+        this.nativeCompactions = [];
+        return pending;
+    }
+    restoreNativeCompactions(compactions) { this.nativeCompactions.unshift(...compactions); }
     async contextUsage() { return this.usage; }
+    async contextUsageAfterNativeCompaction(compaction) {
+        if (compaction.usageRevision === undefined || this.usageRevision > compaction.usageRevision)
+            return this.usage;
+        try {
+            await this.waitFor("thread/tokenUsage/updated", () => this.usageRevision > compaction.usageRevision, 5_000);
+            return this.usage;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async sessionUsage() { return this.providerSessionUsage ? { ...this.providerSessionUsage } : undefined; }
     async switchSettings(settings) {
         this.opts.model = settings.model;
@@ -303,8 +369,10 @@ export class CodexAdapter {
             }
             catch { /* ignore non-protocol stdout */ } });
         child.stderr.on("data", (chunk) => { this.stderr = `${this.stderr}${chunk.toString()}`.slice(-8192); });
-        child.on("error", (error) => this.disconnect(error));
-        child.on("close", (code) => this.disconnect(new Error(`Codex app-server exited with code ${code ?? "unknown"}`)));
+        child.on("error", (error) => { if (this.process === child)
+            this.disconnect(error); });
+        child.on("close", (code) => { if (this.process === child)
+            this.disconnect(new Error(`Codex app-server exited with code ${code ?? "unknown"}`)); });
         await this.request("initialize", { clientInfo: { name: "rafi", title: "Rafi", version: "1" }, capabilities: { experimentalApi: true, requestAttestation: false } });
         this.write({ method: "initialized", params: {} });
         this.initialized = true;
@@ -341,6 +409,8 @@ export class CodexAdapter {
         const params = message.params ?? {};
         if (message.method === "item/started") {
             const item = params.item;
+            if (isCodexToolItem(item))
+                this.observedToolCalls += 1;
             const activity = codexItemActivity(item);
             if (activity)
                 this.eventQueue.push({ kind: "activity", provider: "codex", ...activity });
@@ -351,8 +421,21 @@ export class CodexAdapter {
                 this.activeText.push(item.text);
                 this.eventQueue.push({ kind: "text", text: item.text });
             }
-            else if (item?.type === "commandExecution")
+            else if (item?.type === "commandExecution") {
                 this.eventQueue.push({ kind: "tool", name: "command_execution", input: { command: item.command } });
+            }
+            else if (item?.type === "contextCompaction" && !this.manualCompactionInFlight) {
+                // Completion is the provider's authoritative confirmation. Token-usage
+                // notifications may arrive before or after it, so do not make durable
+                // compaction accounting depend on their delivery order.
+                this.nativeCompactions.push({
+                    id: `codex:${this._sessionId ?? "unknown"}:${Date.now()}:${++this.nativeCompactionSequence}`,
+                    occurredAt: new Date().toISOString(),
+                    provider: "codex",
+                    usageRevision: this.usageRevision,
+                });
+                this.eventQueue.push({ kind: "session-transition", transition: "compacted", detail: "provider-native automatic compaction" });
+            }
             else {
                 const activity = codexItemActivity(item, true);
                 if (activity)
@@ -441,6 +524,16 @@ export class CodexAdapter {
                 waiter.reject(error);
         this.notificationWaiters.clear();
     }
+    async restartForAutoCompaction() {
+        const child = this.process;
+        if (!child)
+            return;
+        this.process = undefined;
+        this.initialized = false;
+        this.threadAttached = false;
+        if (child.exitCode === null)
+            child.kill("SIGTERM");
+    }
     buildSkillsAppendix() {
         if (!this.opts.skills?.length)
             return undefined;
@@ -452,6 +545,14 @@ function optionalNonNegative(value) {
     const number = Number(value);
     return Number.isFinite(number) && number >= 0 ? number : undefined;
 }
+function validThreshold(value) {
+    if (!Number.isInteger(value) || value < 1 || value > 99)
+        throw new Error("automatic compaction threshold must be an integer from 1 to 99");
+    return value;
+}
+function tokenLimit(maximum, percentage) {
+    return Math.max(1, Math.floor(maximum * percentage / 100));
+}
 function activityPhase(phase) {
     if (phase === "planning")
         return "planning";
@@ -483,6 +584,9 @@ function codexItemActivity(item, completed = false) {
         return { state: completed ? "received response" : "writing response" };
     return undefined;
 }
+function isCodexToolItem(item) {
+    return item?.type === "commandExecution" || item?.type === "mcpToolCall" || item?.type === "dynamicToolCall" || item?.type === "webSearch" || item?.type === "fileChange";
+}
 function loadSkillMarkdown(cwd, skill) {
     const projectPath = join(cwd, ".agents", "skills", skill, "SKILL.md");
     if (existsSync(projectPath))

package/dist/adapters/recovering.d.ts

@@ -1,5 +1,5 @@
 import type { AgentRuntime } from "../runtimeAuth.js";
-import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, ProviderSessionUsage, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, TurnResult } from "./types.js";
 import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 export type TurnRecoveryChoice = "retry" | "switch" | "cancel";
 export interface RecoveringAdapterOptions {
@@ -29,6 +29,10 @@ export declare class RecoveringAdapter implements BuilderAdapter {
     adoptSessionRef(ref: ProviderSessionRefV1): void;
     validateSession(): Promise<SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<void>;
+    drainNativeCompactions(): import("./types.js").NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     events(): AsyncIterable<BuilderEvent>;

package/dist/adapters/recovering.js

@@ -67,6 +67,10 @@ export class RecoveringAdapter {
         return this.adapter.validateSession?.() ?? Promise.resolve({ version: 1, status: "unknown", checkedAt: new Date().toISOString(), reason: "legacy-unscoped", detail: "wrapped adapter does not expose scoped session validation" });
     }
     compact() { return this.adapter.compact?.() ?? Promise.resolve({ ok: false, error: "native compaction unavailable" }); }
+    prepareAutoCompaction(thresholdPercent) { return this.adapter.prepareAutoCompaction?.(thresholdPercent) ?? Promise.resolve(); }
+    drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
+    restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
+    contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     events() {

package/dist/adapters/types.d.ts

@@ -122,6 +122,15 @@ export interface CompactResult {
     /** Preserve exact-session loss so lifecycle policy never treats it as an ordinary retryable compaction failure. */
     failure?: RuntimeFailure;
 }
+/** A provider-confirmed compaction that happened without Rafi issuing /compact. */
+export interface NativeCompaction {
+    /** Stable for the lifetime of an adapter; used for durable idempotency. */
+    id: string;
+    occurredAt: string;
+    provider: "claude" | "codex";
+    /** Adapter-local usage generation captured with the provider confirmation. */
+    usageRevision?: number;
+}
 export interface ProviderSettingSwitch {
     model?: string;
     effort?: EffortLevel;
@@ -163,6 +172,8 @@ export interface BuilderAdapterOptions {
     systemPromptAppend?: string;
     /** Skill names to preload for this session (Claude: lazy-loaded; Codex: flattened). */
     skills?: string[];
+    /** Provider-native context ceiling, as a percentage of that provider's model window. */
+    autoCompactThresholdPercent?: number;
 }
 export interface BuilderAdapter {
     readonly agent: "claude" | "codex";
@@ -178,6 +189,18 @@ export interface BuilderAdapter {
     validateSession?(): Promise<SessionAvailabilityV1>;
     /** Provider-native compaction on the exact live conversation. */
     compact?(): Promise<CompactResult>;
+    /**
+     * Install and verify provider-native automatic compaction before role work is
+     * dispatched. This intentionally happens outside a work turn so a long,
+     * tool-heavy first turn is protected too.
+     */
+    prepareAutoCompaction?(thresholdPercent?: number): Promise<void>;
+    /** Consume provider-native compactions observed since the prior drain. */
+    drainNativeCompactions?(): NativeCompaction[];
+    /** Return a drained batch to the adapter when durable receipt failed. */
+    restoreNativeCompactions?(compactions: NativeCompaction[]): void;
+    /** Return occupancy known to postdate a native-compaction event, if available. */
+    contextUsageAfterNativeCompaction?(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     /** Truthful provider context occupancy, when exposed by the provider. */
     contextUsage?(): Promise<ContextUsage | undefined>;
     /** Provider/session cumulative totals; distinct from live context occupancy. */

package/dist/branch/currentGuard.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "../adapters/types.js";
+import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "../adapters/types.js";
 import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 export interface CurrentWorkflowIdentity {
     worktree: string;
@@ -26,6 +26,10 @@ export declare class CurrentWorkflowGuardAdapter implements BuilderAdapter {
     adoptSessionRef(ref: ProviderSessionRefV1): void;
     validateSession(): Promise<SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<void>;
+    drainNativeCompactions(): import("../adapters/types.js").NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;

package/dist/branch/currentGuard.js

@@ -48,6 +48,10 @@ export class CurrentWorkflowGuardAdapter {
     adoptSessionRef(ref) { this.adapter.adoptSessionRef?.(ref); }
     validateSession() { assertCurrentWorkflowIdentity(this.cwd, this.expected); return this.adapter.validateSession?.() ?? Promise.resolve({ version: 1, status: "unknown", checkedAt: new Date().toISOString(), reason: "legacy-unscoped" }); }
     async compact() { assertCurrentWorkflowIdentity(this.cwd, this.expected); const result = await (this.adapter.compact?.() ?? Promise.resolve({ ok: false, error: "native compaction unavailable" })); assertCurrentWorkflowIdentity(this.cwd, this.expected); return result; }
+    prepareAutoCompaction(thresholdPercent) { return this.adapter.prepareAutoCompaction?.(thresholdPercent) ?? Promise.resolve(); }
+    drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
+    restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
+    contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     switchSettings(settings) { return this.adapter.switchSettings?.(settings) ?? Promise.resolve({ ok: false, error: "settings switch unavailable" }); }

package/dist/branch/runner.d.ts

@@ -56,6 +56,8 @@ export interface BranchRunnerOptions {
     builderSessionStrategy?: SessionStrategy;
     qaSessionStrategy?: SessionStrategy;
     observeBuilder?: (builder: BuilderAdapter) => Promise<void>;
+    observeBuilderNativeCompactions?: (builder: BuilderAdapter, cwd: string) => Promise<void>;
+    observeQaNativeCompactions?: (adapter: BuilderAdapter) => Promise<void>;
     qaNonconvergence?: (context: QaNonconvergenceContext) => Promise<QaNonconvergenceDecision>;
     beforeBuilderTurn?: (adapter: BuilderAdapter, frozenAction: string, cwd: string) => Promise<BuilderAdapter>;
     builderSessionBoundary?: (adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy, cwd: string) => Promise<BuilderAdapter>;

package/dist/branch/runner.js

@@ -173,7 +173,7 @@ export async function runBranchPlan(opts) {
             }
             builderWorkSessions += 1;
             viewer = opts.observeBuilder?.(builder);
-            const foreman = new Foreman(builder, opts.log, opts.notificationsEnabled, opts.qaEnabled, 3, undefined, undefined, undefined, opts.qaSessionStrategy ?? "compact", undefined, opts.builderSessionStrategy ?? "compact", undefined, opts.beforeBuilderTurn ? (adapter, action) => opts.beforeBuilderTurn(adapter, action, worktreePath) : undefined);
+            const foreman = new Foreman(builder, opts.log, opts.notificationsEnabled, opts.qaEnabled, 3, undefined, undefined, undefined, opts.qaSessionStrategy ?? "compact", undefined, opts.builderSessionStrategy ?? "compact", undefined, opts.beforeBuilderTurn ? (adapter, action) => opts.beforeBuilderTurn(adapter, action, worktreePath) : undefined, undefined, undefined, async (adapter) => opts.observeBuilderNativeCompactions?.(adapter, worktreePath));
             const { result, status } = await foreman.runInstruction(ticketInstruction);
             builder = foreman.builderAdapter();
             workflowCheckpoint(opts.projectDir, opts.runId, "builder-after", node.ticket.id, { status: status.kind, sessionId: builder.sessionId(), worktree: worktreePath });
@@ -242,6 +242,7 @@ export async function runBranchPlan(opts) {
                     ticket: node.ticket, builderWorktree: worktreePath, builderSummary: status.summary ?? result.text,
                     qaStrategy: opts.qaSessionStrategy ?? "compact", state: qaStream, createQa: opts.createQa, maxCycles: 3,
                     sessionBoundary: opts.qaSessionBoundary,
+                    observeNativeCompactions: opts.observeQaNativeCompactions,
                     evidence: (entry) => opts.log.write("qa-evidence", { ticket: node.ticket.id, ...entry }),
                     fix: async (issues) => {
                         if (!builder)

package/dist/cli/start.js

@@ -37,7 +37,7 @@ import { eligibleTickets, evaluateTicketEligibility } from "../tickets/eligibili
 import { BUILTIN_BRANCH_PREFIX, validateBranchPrefix } from "../branch/prefix.js";
 import { captureCurrentWorkflowSessionIdentity, CurrentWorkflowChangedError, CurrentWorkflowGuardAdapter } from "../branch/currentGuard.js";
 import { ContinuityAdapter, ContinuityRecoveryRequiredError, SessionUnavailableContinuityError } from "../continuity.js";
-import { ContextCapabilityError, RoleSessionController } from "../sessionLifecycle.js";
+import { ContextCapabilityError, RoleSessionController, ThresholdCompactionController } from "../sessionLifecycle.js";
 import { HandoffLoopError, HandoffService, parseBuilderHandoffRequest } from "../handoffs.js";
 import { captureWorkspaceIdentity, createProviderSessionRef, resolveUniqueSessionBinding } from "../sessionIdentity.js";
 import { SessionUnavailableError } from "../adapters/sessionFailure.js";
@@ -625,6 +625,7 @@ export function buildStartCommand() {
                 fast: builderFast,
                 systemPromptAppend: roleBundle.system || undefined,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
+                autoCompactThresholdPercent: thresholdOverride ?? roleDefaults.builder?.auto_compact_threshold_percent ?? 50,
             };
             const adapter = agent === "codex"
                 ? new CodexAdapter(adapterOpts)
@@ -636,6 +637,7 @@ export function buildStartCommand() {
                     throw new SessionUnavailableError({ runtime: "codex", phase: "preflight", dispatchState: "not-sent", executable: agentExecutable ?? "codex", cwd: builderCwd, diagnostics: availability.detail ?? `Codex session ${sessionRef.sessionId} is ${availability.status}`, availability });
                 }
             }
+            await prepareNativeAutoCompaction(adapter);
             return !branchMode ? new CurrentWorkflowGuardAdapter(adapter, builderCwd) : adapter;
         };
         let activeContinuityRunId;
@@ -651,7 +653,8 @@ export function buildStartCommand() {
             role, source: roleDefaults.qa ? "project" : "provider", make: qaAgent, model: qaModel ?? "default",
             reasoning: qaEffort ?? "default", fast: qaFast, session_strategy: roleDefaults.qa?.session_strategy ?? "compact",
             settings_revision: settingsRevision, display_session_cost: sessionCostOverride ?? roleDefaults.qa?.display_session_cost ?? false,
-            auto_compact_threshold_percent: 50, compact_maximum: 10,
+            auto_compact_threshold_percent: roleDefaults.qa?.auto_compact_threshold_percent ?? 50,
+            compact_maximum: roleDefaults.qa?.compact_maximum ?? 10,
         };
         const liveRoleSettings = (role, base) => {
             const live = readAgentDefaults(cwd);
@@ -696,8 +699,10 @@ export function buildStartCommand() {
                 fast: settings.fast,
                 systemPromptAppend: roleBundle.system || undefined,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
+                autoCompactThresholdPercent: settings.auto_compact_threshold_percent,
             };
             const created = settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            await prepareNativeAutoCompaction(created);
             return !branchMode ? new CurrentWorkflowGuardAdapter(created, builderCwd) : created;
         };
         const createQaForSettings = async (qaCwd, settings) => {
@@ -722,8 +727,11 @@ export function buildStartCommand() {
                 fast: settings.fast,
                 systemPromptAppend: `${roleBundle.system}\n\nYou are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.`,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
+                autoCompactThresholdPercent: settings.auto_compact_threshold_percent,
             };
-            return settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            const created = settings.make === "codex" ? new CodexAdapter(adapterOptions) : await ClaudeAdapter.create(adapterOptions);
+            await prepareNativeAutoCompaction(created);
+            return created;
         };
         const createRecoveringBuilder = async (builderCwd, sessionId, sessionRef) => {
             if (sessionId && !sessionRef) {
@@ -910,6 +918,16 @@ export function buildStartCommand() {
             return continuousBuilder(transfer.successor, builderCwd, runId, input.next);
         };
         const createRawQa = async (qaCwd, sessionRef) => {
+            // Isolated QA conversations are intentionally disposable. Resolve live
+            // QA settings for each one so a threshold-only update applies to the
+            // very next review instead of waiting for a nonexistent session reuse.
+            const qaSettings = liveRoleSettings("qa", resolvedContinuitySettings("qa"));
+            const ready = await ensureRuntimeReadyForCommand(qaCwd, qaSettings.make, {
+                label: "live QA settings",
+                yes: true,
+                allowSwitch: false,
+                model: qaSettings.model === "default" ? undefined : qaSettings.model,
+            });
             const qaPolicy = new PermissionPolicy(config.permissions, qaCwd);
             const roleBundle = loadRoleBundle("qa", { projectDir: qaCwd });
             const adapterOpts = {
@@ -917,21 +935,24 @@ export function buildStartCommand() {
                 configRoot: cwd,
                 sessionRole: "qa",
                 sessionStream: "qa",
-                runtimeExecutable: qaExecutable,
+                runtimeExecutable: ready.executable,
                 runtimePhase: "qa",
-                model: qaModel,
+                model: qaSettings.model === "default" ? undefined : qaSettings.model,
                 ...(sessionRef ? { resumeSessionRef: sessionRef } : {}),
                 sessionGeneration: sessionRef?.generation ?? 0,
                 workspaceIdentity: captureWorkspaceIdentity(qaCwd),
                 permission: createPermissionHandler(qaPolicy, log),
-                effort: qaEffort,
-                fast: qaFast,
+                effort: explicitEffort(qaSettings.reasoning),
+                fast: qaSettings.fast,
                 systemPromptAppend: `${roleBundle.system}\n\nYou are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.`,
                 skills: roleBundle.skills.length > 0 ? roleBundle.skills : undefined,
+                autoCompactThresholdPercent: qaSettings.auto_compact_threshold_percent,
             };
-            return qaAgent === "codex"
+            const created = qaSettings.make === "codex"
                 ? new CodexAdapter(adapterOpts)
                 : await ClaudeAdapter.create(adapterOpts);
+            await prepareNativeAutoCompaction(created);
+            return created;
         };
         const createRecoveringQa = async (qaCwd, sessionRef) => {
             const initial = await createRawQa(qaCwd, sessionRef);
@@ -1152,7 +1173,7 @@ export function buildStartCommand() {
                 runId: activeContinuityRunId,
                 role: "qa",
                 initialSettings: qaSettings,
-                historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+                historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, activeContinuityRunId, "qa"),
                 readSettings: () => liveRoleSettings("qa", qaSettings),
                 settingsBoundary: (input) => applyQaSettingsBoundary(activeContinuityRunId, qaCwd, input),
                 settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1185,6 +1206,19 @@ export function buildStartCommand() {
             });
             return (await controller.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter;
         };
+        const observeQaNativeCompactions = async (adapter) => {
+            if (!activeContinuityRunId)
+                return;
+            const qaSettings = resolvedContinuitySettings("qa");
+            const controller = new ThresholdCompactionController({
+                projectDir: cwd,
+                runId: activeContinuityRunId,
+                role: "qa",
+                initialSettings: qaSettings,
+                historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, activeContinuityRunId, "qa"),
+            });
+            await controller.observeNativeCompactions(adapter);
+        };
         const qaNonconvergence = createQaNonconvergenceHandler(cwd, Boolean(opts.yes), roleDefaults.planner);
         if (branchMode) {
             const ticketsConfig = loadTicketsConfig(cwd);
@@ -1416,7 +1450,8 @@ export function buildStartCommand() {
                 role: "qa", source: roleDefaults.qa ? "project" : "provider", make: qaAgent, model: qaModel ?? "default",
                 reasoning: qaEffort ?? "default", fast: qaFast, session_strategy: roleDefaults.qa?.session_strategy ?? "compact", settings_revision: settingsRevision,
                 display_session_cost: sessionCostOverride ?? roleDefaults.qa?.display_session_cost ?? false,
-                auto_compact_threshold_percent: 50, compact_maximum: 10,
+                auto_compact_threshold_percent: roleDefaults.qa?.auto_compact_threshold_percent ?? 50,
+                compact_maximum: roleDefaults.qa?.compact_maximum ?? 10,
             };
             const firstResumeRef = plan.nodes[0] ? resumeSessionByTicket.get(plan.nodes[0].ticket.id)?.sessionRef : undefined;
             let masterRun = recoveryRecord ? resumeBuildRun(cwd, recoveryRecord.runId, { builder: capturedBranchBuilder, qa: capturedBranchQa, builderSessionId: firstResumeRef?.sessionId ?? null, builderSessionRef: firstResumeRef ?? null }) : createBuildRun({
@@ -1432,7 +1467,7 @@ export function buildStartCommand() {
                     return existing;
                 const controller = RoleSessionController.managed({
                     projectDir: cwd, runId: masterRun.runId, role: "builder", initialSettings: capturedBranchBuilder,
-                    historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+                    historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, masterRun.runId, "builder"),
                     readSettings: () => liveRoleSettings("builder", capturedBranchBuilder),
                     settingsBoundary: (input) => applyBuilderSettingsBoundary(masterRun.runId, worktreePath, input),
                     settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1547,8 +1582,10 @@ export function buildStartCommand() {
                 },
                 qaNonconvergence,
                 beforeBuilderTurn: async (adapter, frozenAction, worktreePath) => (await branchContextController(worktreePath).atSafeBoundary(adapter, frozenAction)).adapter,
+                observeBuilderNativeCompactions: async (adapter, worktreePath) => { await branchContextController(worktreePath).observeNativeCompactions(adapter); },
                 builderSessionBoundary: async (adapter, frozenAction, strategy, worktreePath) => (await branchContextController(worktreePath).atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter,
                 qaSessionBoundary,
+                observeQaNativeCompactions,
             });
             if (branchSessionFailure) {
                 const failure = branchSessionFailure;
@@ -1653,7 +1690,7 @@ export function buildStartCommand() {
             auto_compact_threshold_percent: thresholdOverride ?? roleDefaults.builder?.auto_compact_threshold_percent ?? 50,
             compact_maximum: roleDefaults.builder?.compact_maximum ?? 10,
         };
-        const capturedQa = { role: "qa", source: roleDefaults.qa ? "project" : "provider", make: qaAgent, model: qaModel ?? "default", reasoning: qaEffort ?? "default", fast: qaFast, session_strategy: roleDefaults.qa?.session_strategy ?? "compact", display_session_cost: sessionCostOverride ?? roleDefaults.qa?.display_session_cost ?? false, auto_compact_threshold_percent: 50, compact_maximum: 10, settings_revision: settingsRevision };
+        const capturedQa = { role: "qa", source: roleDefaults.qa ? "project" : "provider", make: qaAgent, model: qaModel ?? "default", reasoning: qaEffort ?? "default", fast: qaFast, session_strategy: roleDefaults.qa?.session_strategy ?? "compact", display_session_cost: sessionCostOverride ?? roleDefaults.qa?.display_session_cost ?? false, auto_compact_threshold_percent: roleDefaults.qa?.auto_compact_threshold_percent ?? 50, compact_maximum: roleDefaults.qa?.compact_maximum ?? 10, settings_revision: settingsRevision };
         let buildRun = recoveryRecord ? resumeBuildRun(cwd, recoveryRecord.runId, { builder: capturedBuilder, qa: capturedQa, builderSessionId: resumeSessionId ?? null, builderSessionRef: resumeSessionRef ?? null }) : createBuildRun({
             tickets: [], repositoryRoot: cwd, branchMode: "current", baseRef: opts.base ?? loadTicketSetupConfig(cwd)?.build.base_branch, builder: capturedBuilder, qa: capturedQa,
             runDecisions: { workMode: "current", workModeSource, branchPrefix, branchPrefixSource: resolvedPrefix.source, autoCompactThresholdPercent: capturedBuilder.auto_compact_threshold_percent ?? 50, thresholdSource: thresholdOverride === undefined ? "project" : "cli" },
@@ -1692,7 +1729,7 @@ export function buildStartCommand() {
             runId: buildRun.runId,
             role: "builder",
             initialSettings: capturedBuilder,
-            historicalCountUncertain: Boolean(recoveryRecord && (recoveryRecord.legacy || !recoveryRecord.runDecisions)),
+            historicalCountUncertain: recoveryCompactionHistoryUncertain(cwd, recoveryRecord, buildRun.runId, "builder"),
             readSettings: () => liveRoleSettings("builder", capturedBuilder),
             settingsBoundary: (input) => applyBuilderSettingsBoundary(buildRun.runId, cwd, input),
             settingsAdopted: (settings, active) => liveStatusReporter?.updateState({
@@ -1732,7 +1769,7 @@ export function buildStartCommand() {
                 return continuousBuilder(transfer.successor, cwd, buildRun.runId, settings);
             },
         });
-        const foreman = new Foreman(builder, log, config.notifications.enabled, qaEnabled, 3, cwd, undefined, qaEnabled ? createQa : undefined, capturedQa.session_strategy, createBuilder, capturedBuilder.session_strategy, qaNonconvergence, async (adapter, frozenAction) => (await contextController.atSafeBoundary(adapter, frozenAction)).adapter, async (adapter, frozenAction, strategy) => (await contextController.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter, qaSessionBoundary);
+        const foreman = new Foreman(builder, log, config.notifications.enabled, qaEnabled, 3, cwd, undefined, qaEnabled ? createQa : undefined, capturedQa.session_strategy, createBuilder, capturedBuilder.session_strategy, qaNonconvergence, async (adapter, frozenAction) => (await contextController.atSafeBoundary(adapter, frozenAction)).adapter, async (adapter, frozenAction, strategy) => (await contextController.atWorkSessionBoundary(adapter, frozenAction, strategy)).adapter, qaSessionBoundary, observeQaNativeCompactions, async (adapter) => { await contextController.observeNativeCompactions(adapter); });
         activeBuilderForStatus = () => foreman.builderAdapter();
         const statusReporter = liveStatusReporter = new AgentStatusReporter({
             runId: buildRun.runId,
@@ -1916,6 +1953,19 @@ export function buildStartCommand() {
         }
     });
 }
+async function prepareNativeAutoCompaction(adapter) {
+    if (!adapter.prepareAutoCompaction) {
+        await adapter.close().catch(() => { });
+        throw new Error(`${adapter.agent} does not support provider-native automatic compaction`);
+    }
+    try {
+        await adapter.prepareAutoCompaction();
+    }
+    catch (error) {
+        await adapter.close().catch(() => { });
+        throw error;
+    }
+}
 function createQaNonconvergenceHandler(projectDir, noninteractive, planner) {
     return async (context) => {
         if (noninteractive || !process.stdin.isTTY || !process.stdout.isTTY)
@@ -2018,6 +2068,19 @@ function readAgentDefaults(projectDir) {
 function explicitDefaultValue(value) {
     return value && value !== "default" ? value : undefined;
 }
+function recoveryCompactionHistoryUncertain(projectDir, recovery, runId, role) {
+    if (!recovery)
+        return false;
+    if (recovery.legacy || !recovery.runDecisions || !runId)
+        return true;
+    const db = new WorkflowDb(projectDir);
+    try {
+        return db.hasUncheckpointedRoleTurn(runId, role);
+    }
+    finally {
+        db.close();
+    }
+}
 /** Make the executable branch plan exactly match each explicit root-to-tip stack. */
 export function applyExplicitStackTopology(plan, stacks, delivery, branchPrefix) {
     const nodeByTicket = new Map(plan.nodes.map((node) => [node.ticket.id, node]));

package/dist/continuity.d.ts

@@ -1,5 +1,5 @@
 import type { ContinuityDelta, ResolvedAgentSettings } from "rafi-spec";
-import type { BuilderAdapter, CompactResult, ContextUsage, ProviderSessionUsage, ProviderSettingSwitch, RuntimeFailure, TurnResult } from "./adapters/types.js";
+import type { BuilderAdapter, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, RuntimeFailure, TurnResult } from "./adapters/types.js";
 export declare const CONTINUITY_MARKER = "RAFI_CONTINUITY_DELTA:";
 export declare class ContinuityValidationError extends Error {
     readonly problems: string[];
@@ -70,6 +70,10 @@ export declare class ContinuityAdapter implements BuilderAdapter {
     adoptSessionRef(ref: import("rafi-spec").ProviderSessionRefV1): void;
     validateSession(): Promise<import("rafi-spec").SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<void>;
+    drainNativeCompactions(): import("./adapters/types.js").NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;

package/dist/continuity.js

@@ -232,6 +232,10 @@ export class ContinuityAdapter {
     adoptSessionRef(ref) { this.adapter.adoptSessionRef?.(ref); }
     validateSession() { return this.adapter.validateSession?.() ?? Promise.resolve({ version: 1, status: "unknown", checkedAt: new Date().toISOString(), reason: "legacy-unscoped" }); }
     compact() { return this.adapter.compact ? this.adapter.compact() : Promise.resolve({ ok: false, error: "provider adapter does not expose native compaction" }); }
+    prepareAutoCompaction(thresholdPercent) { return this.adapter.prepareAutoCompaction?.(thresholdPercent) ?? Promise.resolve(); }
+    drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
+    restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
+    contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     switchSettings(settings) { return this.adapter.switchSettings ? this.adapter.switchSettings(settings) : Promise.resolve({ ok: false, error: "provider adapter does not support settings changes" }); }

package/dist/foreman.d.ts

@@ -65,10 +65,15 @@ export declare class Foreman {
     private readonly beforeBuilderTurn?;
     private readonly builderSessionBoundary?;
     private readonly qaSessionBoundary?;
+    private readonly observeQaNativeCompactions?;
+    /** Persist a Builder's provider-native event immediately after every turn. */
+    private readonly observeBuilderNativeCompactions?;
     private readonly ticketsEnabled;
     private readonly qaStream;
     private builderWorkSessions;
-    constructor(builder: BuilderAdapter, log: Log, notificationsEnabled?: boolean, qaEnabled?: boolean, qaMaxCycles?: number, projectDir?: string | undefined, qaReviewer?: BuilderAdapter | undefined, qaFactory?: ((cwd: string, sessionId?: string) => Promise<BuilderAdapter>) | undefined, qaSessionStrategy?: SessionStrategy, builderFactory?: ((cwd: string, sessionId?: string) => Promise<BuilderAdapter>) | undefined, builderSessionStrategy?: SessionStrategy, qaNonconvergence?: ((context: QaNonconvergenceContext) => Promise<QaNonconvergenceDecision>) | undefined, beforeBuilderTurn?: ((adapter: BuilderAdapter, frozenAction: string) => Promise<BuilderAdapter>) | undefined, builderSessionBoundary?: ((adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy) => Promise<BuilderAdapter>) | undefined, qaSessionBoundary?: ((adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy, cwd: string) => Promise<BuilderAdapter>) | undefined);
+    constructor(builder: BuilderAdapter, log: Log, notificationsEnabled?: boolean, qaEnabled?: boolean, qaMaxCycles?: number, projectDir?: string | undefined, qaReviewer?: BuilderAdapter | undefined, qaFactory?: ((cwd: string, sessionId?: string) => Promise<BuilderAdapter>) | undefined, qaSessionStrategy?: SessionStrategy, builderFactory?: ((cwd: string, sessionId?: string) => Promise<BuilderAdapter>) | undefined, builderSessionStrategy?: SessionStrategy, qaNonconvergence?: ((context: QaNonconvergenceContext) => Promise<QaNonconvergenceDecision>) | undefined, beforeBuilderTurn?: ((adapter: BuilderAdapter, frozenAction: string) => Promise<BuilderAdapter>) | undefined, builderSessionBoundary?: ((adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy) => Promise<BuilderAdapter>) | undefined, qaSessionBoundary?: ((adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy, cwd: string) => Promise<BuilderAdapter>) | undefined, observeQaNativeCompactions?: ((adapter: BuilderAdapter) => Promise<void>) | undefined, 
+    /** Persist a Builder's provider-native event immediately after every turn. */
+    observeBuilderNativeCompactions?: ((adapter: BuilderAdapter) => Promise<void>) | undefined);
     /**
      * Send one instruction and resolve any needs_input exchanges before returning.
      * The returned result and status always reflect the final (non-needs_input) turn.
@@ -85,6 +90,7 @@ export declare class Foreman {
         result: TurnResult;
         status: StepStatus;
     }>;
+    private observeBuilderNative;
     /**
      * Run a QA review pass on the ticket the builder just completed.
      * Loops on qa_fail → fix → re-QA until qa_pass or the cycle cap is reached.

package/dist/foreman.js

@@ -229,10 +229,14 @@ export class Foreman {
     beforeBuilderTurn;
     builderSessionBoundary;
     qaSessionBoundary;
+    observeQaNativeCompactions;
+    observeBuilderNativeCompactions;
     ticketsEnabled;
     qaStream = { reviews: 0, modificationViolations: 0 };
     builderWorkSessions = 0;
-    constructor(builder, log, notificationsEnabled = false, qaEnabled = true, qaMaxCycles = 3, projectDir, qaReviewer, qaFactory, qaSessionStrategy = "compact", builderFactory, builderSessionStrategy = "compact", qaNonconvergence, beforeBuilderTurn, builderSessionBoundary, qaSessionBoundary) {
+    constructor(builder, log, notificationsEnabled = false, qaEnabled = true, qaMaxCycles = 3, projectDir, qaReviewer, qaFactory, qaSessionStrategy = "compact", builderFactory, builderSessionStrategy = "compact", qaNonconvergence, beforeBuilderTurn, builderSessionBoundary, qaSessionBoundary, observeQaNativeCompactions, 
+    /** Persist a Builder's provider-native event immediately after every turn. */
+    observeBuilderNativeCompactions) {
         this.builder = builder;
         this.log = log;
         this.notificationsEnabled = notificationsEnabled;
@@ -248,6 +252,8 @@ export class Foreman {
         this.beforeBuilderTurn = beforeBuilderTurn;
         this.builderSessionBoundary = builderSessionBoundary;
         this.qaSessionBoundary = qaSessionBoundary;
+        this.observeQaNativeCompactions = observeQaNativeCompactions;
+        this.observeBuilderNativeCompactions = observeBuilderNativeCompactions;
         this.ticketsEnabled = !!(projectDir && isTicketsInitialized(projectDir));
     }
     /**
@@ -309,6 +315,7 @@ export class Foreman {
             adapter = this.builder;
         }
         let result = await adapter.sendTurn(instruction);
+        await this.observeBuilderNative(adapter);
         let status = parseStepStatus(result.text);
         if (result.failure?.category === "session-unavailable")
             return { result, status };
@@ -318,9 +325,14 @@ export class Foreman {
             }
             else {
                 const qa = /\bQA\b|qa_pass|qa_fail/i.test(instruction);
+                if (adapter === this.builder && this.beforeBuilderTurn) {
+                    this.builder = await this.beforeBuilderTurn(this.builder, instruction);
+                    adapter = this.builder;
+                }
                 result = await adapter.sendTurn(qa
                     ? "Protocol correction only: based on the review already completed, return exactly one final STEP_STATUS: qa_pass or STEP_STATUS: qa_fail marker. Do not repeat QA, tests, tools, or compaction."
                     : "Protocol correction only: based on the work already completed, return exactly one final STEP_STATUS: done, plan_complete, blocked, or needs_input marker. Do not repeat implementation, tools, or compaction.");
+                await this.observeBuilderNative(adapter);
                 status = parseStepStatus(result.text);
                 if (status.kind === "unknown")
                     status = { ...status, error: `protocol correction exhausted: ${status.error ?? "missing final marker"}` };
@@ -346,7 +358,12 @@ export class Foreman {
                 status = { kind: "blocked", reason: "user cancelled at input prompt" };
                 break;
             }
+            if (adapter === this.builder && this.beforeBuilderTurn) {
+                this.builder = await this.beforeBuilderTurn(this.builder, String(answer));
+                adapter = this.builder;
+            }
             result = await adapter.sendTurn(String(answer));
+            await this.observeBuilderNative(adapter);
             status = parseStepStatus(result.text);
         }
         return { result, status };
@@ -357,6 +374,7 @@ export class Foreman {
         if (this.beforeBuilderTurn)
             this.builder = await this.beforeBuilderTurn(this.builder, instruction);
         const result = await this.builder.sendTurn(instruction);
+        await this.observeBuilderNative(this.builder);
         this.log.write("preflight", {
             ticketsProvided: ticketsContent !== undefined,
             costUsd: result.costUsd,
@@ -371,6 +389,7 @@ export class Foreman {
         if (this.beforeBuilderTurn)
             this.builder = await this.beforeBuilderTurn(this.builder, feedback);
         const result = await this.builder.sendTurn(feedback);
+        await this.observeBuilderNative(this.builder);
         this.log.write("preflight", { feedback: true, costUsd: result.costUsd, isError: result.isError });
         if (result.isError)
             throw new Error(result.text);
@@ -379,6 +398,10 @@ export class Foreman {
     async runInstruction(instruction) {
         return this.doTurn(instruction);
     }
+    async observeBuilderNative(adapter) {
+        if (adapter === this.builder)
+            await this.observeBuilderNativeCompactions?.(adapter);
+    }
     /**
      * Run a QA review pass on the ticket the builder just completed.
      * Loops on qa_fail → fix → re-QA until qa_pass or the cycle cap is reached.
@@ -394,6 +417,7 @@ export class Foreman {
                 state: this.qaStream,
                 createQa: this.qaFactory,
                 sessionBoundary: this.qaSessionBoundary,
+                observeNativeCompactions: this.observeQaNativeCompactions,
                 maxCycles: this.qaMaxCycles,
                 fix: async (issues) => {
                     const instruction = buildQaFixInstruction(issues);

package/dist/qaReview.d.ts

@@ -29,6 +29,8 @@ export interface IsolatedQaOptions {
     createQa: (cwd: string, sessionId?: string) => Promise<BuilderAdapter>;
     /** Host-owned ordinary QA boundary. Fresh strategies must return a validated successor. */
     sessionBoundary?: (adapter: BuilderAdapter, frozenAction: string, strategy: SessionStrategy, cwd: string) => Promise<BuilderAdapter>;
+    /** Persist provider-native automatic compactions without imposing an ordinary QA boundary. */
+    observeNativeCompactions?: (adapter: BuilderAdapter) => Promise<void>;
     fix: (issues: string) => Promise<{
         ok: boolean;
         detail?: string;

package/dist/qaReview.js

@@ -51,6 +51,7 @@ async function oneReview(opts, cycle) {
         qa = await opts.createQa(snapshot.path);
         const turn = await qa.sendTurn(handoff);
         const status = parseStepStatus(turn.text);
+        await opts.observeNativeCompactions?.(qa);
         opts.state.reviews += 1;
         opts.state.sessionId = qa.sessionId();
         opts.state.sessionRef = qa.sessionRef?.();

package/dist/sessionLifecycle.d.ts

@@ -49,6 +49,8 @@ export declare class RoleSessionController {
     static managed(options: ThresholdCompactionOptions): RoleSessionController;
     atSafeBoundary(adapter: BuilderAdapter, frozenAction: string): Promise<ContextBoundaryResult>;
     atWorkSessionBoundary(adapter: BuilderAdapter, frozenAction: string, strategy?: SessionStrategy): Promise<ContextBoundaryResult>;
+    /** Record provider-native automatic compaction immediately after a role turn. */
+    observeNativeCompactions(adapter: BuilderAdapter): Promise<number | undefined>;
     effectiveSettings(): ResolvedAgentSettings;
     effectiveThreshold(): number;
     next(durableHandoff: string, nextSettings?: ResolvedAgentSettings): Promise<SessionBoundary>;
@@ -125,10 +127,13 @@ export declare class ThresholdCompactionController {
     atWorkSessionBoundary(adapter: BuilderAdapter, frozenAction: string, strategy?: SessionStrategy): Promise<ContextBoundaryResult>;
     effectiveSettings(): ResolvedAgentSettings;
     effectiveThreshold(): number;
+    /** Persist provider-triggered compactions at a host-owned boundary. */
+    observeNativeCompactions(adapter: BuilderAdapter, afterSample?: ContextSample): Promise<number | undefined>;
     private compactSession;
     private performHandoff;
     private adoptSettings;
     private measure;
+    private sampleFromUsage;
     private compactionCount;
     private handoffGeneration;
     private threshold;

package/dist/sessionLifecycle.js

@@ -67,6 +67,13 @@ export class RoleSessionController {
         this.adapter = result.adapter;
         return result;
     }
+    /** Record provider-native automatic compaction immediately after a role turn. */
+    async observeNativeCompactions(adapter) {
+        if (!this.thresholdController)
+            throw new Error("this role session controller does not own threshold lifecycle policy");
+        await this.adoptManagedAdapter(adapter);
+        return this.thresholdController.observeNativeCompactions(adapter);
+    }
     effectiveSettings() {
         return this.thresholdController?.effectiveSettings() ?? this.options.settings;
     }
@@ -329,6 +336,9 @@ export class ThresholdCompactionController {
             }
             return { adapter, action: "continued", sample, effectiveThreshold: this.threshold(), compactionCount: 0 };
         }
+        // Drain first so a provider-confirmed compaction is persisted with a
+        // measurement taken after the event, regardless of provider event order.
+        const nativeCount = await this.observeNativeCompactions(adapter);
         let sample = await this.measure(adapter, "provider-query");
         const threshold = this.threshold();
         let session = adapter.sessionRef?.() ?? adapter.sessionId();
@@ -340,12 +350,20 @@ export class ThresholdCompactionController {
         let count = 0;
         try {
             db.recordContextSample(sample);
-            count = db.successfulCompactionCount(this.options.runId, this.options.role, session);
+            count = nativeCount ?? db.successfulCompactionCount(this.options.runId, this.options.role, session);
         }
         finally {
             db.close();
         }
+        // An interrupted dispatched turn leaves both conversation state and native
+        // compaction accounting unknowable. Do not continue that exact session,
+        // even if its next occupancy sample happens to be below threshold.
+        if (this.historicalCountUncertain) {
+            return this.performHandoff(adapter, sample, count, frozenAction, "a prior provider turn lacked a durable completion checkpoint; handing off rather than reusing an uncertain session");
+        }
         if ((sample.percentage ?? -1) < threshold) {
+            if (nativeCount !== undefined && count >= (this.settings.compact_maximum ?? 10))
+                return this.performHandoff(adapter, sample, count, frozenAction, `compact maximum ${this.settings.compact_maximum ?? 10} reached after provider-native compaction`);
             this.armed = true;
             return { adapter, action: "below-threshold", sample, effectiveThreshold: threshold, compactionCount: count };
         }
@@ -385,12 +403,13 @@ export class ThresholdCompactionController {
     /** Apply the configured ordinary work-session boundary without bypassing handoff or compaction accounting. */
     async atWorkSessionBoundary(adapter, frozenAction, strategy = this.settings.session_strategy) {
         adapter = await this.adoptSettings(adapter, frozenAction);
+        const nativeCount = await this.observeNativeCompactions(adapter);
         const sample = await this.measure(adapter, "provider-query");
         const db = new WorkflowDb(this.options.projectDir);
         let count = 0;
         try {
             db.recordContextSample(sample);
-            count = db.successfulCompactionCount(this.options.runId, this.options.role, adapter.sessionRef?.() ?? adapter.sessionId());
+            count = nativeCount ?? db.successfulCompactionCount(this.options.runId, this.options.role, adapter.sessionRef?.() ?? adapter.sessionId());
         }
         finally {
             db.close();
@@ -403,6 +422,54 @@ export class ThresholdCompactionController {
     }
     effectiveSettings() { return this.settings; }
     effectiveThreshold() { return this.threshold(); }
+    /** Persist provider-triggered compactions at a host-owned boundary. */
+    async observeNativeCompactions(adapter, afterSample) {
+        const observed = adapter.drainNativeCompactions?.() ?? [];
+        if (observed.length === 0)
+            return undefined;
+        const sessionId = adapter.sessionId();
+        const sessionRef = adapter.sessionRef?.();
+        if (!sessionId || !sessionRef) {
+            adapter.restoreNativeCompactions?.(observed);
+            throw new ContextCapabilityError(this.options.runId, this.options.role, "provider reported automatic compaction without a validated session identity");
+        }
+        const sessionKey = providerSessionKey(sessionRef);
+        const db = new WorkflowDb(this.options.projectDir);
+        try {
+            const keys = [];
+            for (const compaction of observed) {
+                const idempotencyKey = `native-compact:${this.options.runId}:${this.options.role}:${sha(`${sessionKey}:${compaction.id}`).slice(0, 32)}`;
+                keys.push(idempotencyKey);
+                const prior = db.startCompactionAttempt({
+                    idempotencyKey, runId: this.options.runId, role: this.options.role,
+                    providerSessionId: sessionId, sessionRef, sessionKey,
+                    crossingKey: `provider-native:${compaction.provider}:${compaction.id}`,
+                });
+                // Confirmation, not occupancy telemetry, is authoritative for the
+                // count. Persist it first so an out-of-order or unavailable usage
+                // event cannot lose a completed provider compaction.
+                if (prior.status === "started")
+                    db.finishCompactionAttempt(idempotencyKey, { ok: true });
+            }
+            const usage = afterSample ? undefined : await adapter.contextUsageAfterNativeCompaction?.(observed.at(-1));
+            const sample = afterSample ?? (usage ? this.sampleFromUsage(adapter, usage, "post-compact") : undefined);
+            if (sample) {
+                db.recordContextSample(sample);
+                for (const key of keys)
+                    db.recordCompactionAfterSample(key, sample);
+            }
+            return db.successfulCompactionCount(this.options.runId, this.options.role, sessionRef);
+        }
+        catch (error) {
+            // Do not lose a provider confirmation merely because its durable receipt
+            // encountered a transient database/measurement failure.
+            adapter.restoreNativeCompactions?.(observed);
+            throw error;
+        }
+        finally {
+            db.close();
+        }
+    }
     async compactSession(adapter, sample, count, frozenAction, crossingKey, thresholdCrossing, freshBootstrap) {
         const threshold = this.threshold();
         const sessionId = adapter.sessionId();
@@ -558,6 +625,7 @@ export class ThresholdCompactionController {
             || next.model !== this.settings.model
             || next.reasoning !== this.settings.reasoning
             || next.fast !== this.settings.fast;
+        const nativeCompactionChanged = next.auto_compact_threshold_percent !== this.settings.auto_compact_threshold_percent;
         let adoptedAdapter = adapter;
         if (providerControlsChanged) {
             if (this.options.settingsBoundary) {
@@ -577,6 +645,16 @@ export class ThresholdCompactionController {
                 throw new ContextCapabilityError(this.options.runId, this.options.role, `settings revision ${next.settings_revision} requested ${next.make}, but the adopted session reports ${adoptedAdapter.agent}`);
             }
         }
+        if (nativeCompactionChanged && !providerControlsChanged) {
+            if (!adapter.prepareAutoCompaction)
+                throw new ContextCapabilityError(this.options.runId, this.options.role, `settings revision ${next.settings_revision} cannot apply provider-native automatic compaction`);
+            try {
+                await adapter.prepareAutoCompaction(next.auto_compact_threshold_percent);
+            }
+            catch (error) {
+                throw new ContextCapabilityError(this.options.runId, this.options.role, `settings revision ${next.settings_revision} could not apply the automatic-compaction threshold: ${sanitize(error)}`);
+            }
+        }
         this.settings = next;
         this.runOnlyThreshold = undefined;
         const db = new WorkflowDb(this.options.projectDir);
@@ -606,6 +684,9 @@ export class ThresholdCompactionController {
         }
         if (!usage || !Number.isFinite(usage.used))
             throw new ContextCapabilityError(this.options.runId, this.options.role, `truthful context occupancy was unavailable after ${attempts} provider attempt(s)`);
+        return this.sampleFromUsage(adapter, usage, source);
+    }
+    sampleFromUsage(adapter, usage, source) {
         const percentage = usage.percentage ?? (usage.maximum ? usage.used / usage.maximum * 100 : undefined);
         if (percentage === undefined || !Number.isFinite(percentage))
             throw new ContextCapabilityError(this.options.runId, this.options.role, "provider context occupancy lacks a usable percentage and maximum");

package/dist/statusReporter.d.ts

@@ -1,5 +1,5 @@
 import type { ContextSample, SessionUsageSample } from "rafi-spec";
-import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./adapters/types.js";
+import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./adapters/types.js";
 export interface AgentStatusSnapshot {
     role: "builder" | "qa";
     provider: "claude" | "codex";
@@ -82,6 +82,10 @@ export declare class RoleStatusAdapter implements BuilderAdapter {
     adoptSessionRef(ref: import("rafi-spec").ProviderSessionRefV1): void;
     validateSession(): Promise<import("rafi-spec").SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<void>;
+    drainNativeCompactions(): import("./adapters/types.js").NativeCompaction[];
+    restoreNativeCompactions(compactions: NativeCompaction[]): void;
+    contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;

package/dist/statusReporter.js

@@ -177,6 +177,10 @@ export class RoleStatusAdapter {
     adoptSessionRef(ref) { this.adapter.adoptSessionRef?.(ref); }
     validateSession() { return this.adapter.validateSession?.() ?? Promise.resolve({ version: 1, status: "unknown", checkedAt: new Date().toISOString(), reason: "legacy-unscoped" }); }
     compact() { this.onActive(this.adapter); return this.adapter.compact?.() ?? Promise.resolve({ ok: false, error: "native compaction unavailable" }); }
+    prepareAutoCompaction(thresholdPercent) { return this.adapter.prepareAutoCompaction?.(thresholdPercent) ?? Promise.resolve(); }
+    drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
+    restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
+    contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }
     contextUsage() { return this.adapter.contextUsage?.() ?? Promise.resolve(undefined); }
     sessionUsage() { return this.adapter.sessionUsage?.() ?? Promise.resolve(undefined); }
     switchSettings(settings) { return this.adapter.switchSettings?.(settings) ?? Promise.resolve({ ok: false, error: "settings switch unavailable" }); }

package/dist/workflowDb.d.ts

@@ -192,10 +192,18 @@ export declare class WorkflowDb {
         afterSample?: ContextSample;
         error?: string;
     }, now?: Date): CompactionAttemptRecord;
+    /** Attach an eventually available measurement without changing confirmed accounting. */
+    recordCompactionAfterSample(idempotencyKey: string, afterSample: ContextSample, now?: Date): CompactionAttemptRecord;
     compactionAttempt(idempotencyKey: string): CompactionAttemptRecord | undefined;
     successfulCompactionCount(runId: string, role: "builder" | "qa", providerSession?: string | ProviderSessionRefV1): number;
     recordRecoveryDecision(receipt: BuildRecoveryDecisionReceipt): void;
     recoveryDecisions(runId: string): BuildRecoveryDecisionReceipt[];
+    /**
+     * A process may die after dispatching a provider turn but before its durable
+     * continuity checkpoint. The provider may have compacted during that gap, so
+     * recovery must not treat that role session's compaction history as complete.
+     */
+    hasUncheckpointedRoleTurn(runId: string, role: "builder" | "qa"): boolean;
     beginPublication(runId: string, intent: unknown, previousDigests: unknown, now?: Date): PublicationTransaction;
     updatePublication(transactionId: string, status: PublicationTransaction["status"], now?: Date): PublicationTransaction;
     publication(transactionId: string): PublicationTransaction | undefined;

package/dist/workflowDb.js

@@ -455,6 +455,17 @@ export class WorkflowDb {
         this.insertEvent(prior.runId, input.ok ? "compaction_succeeded" : "compaction_failed", `context:${prior.role}`, { idempotencyKey, providerSessionId: prior.providerSessionId, sessionKey: prior.sessionKey, crossingKey: prior.crossingKey }, now.toISOString());
         return this.compactionAttempt(idempotencyKey);
     }
+    /** Attach an eventually available measurement without changing confirmed accounting. */
+    recordCompactionAfterSample(idempotencyKey, afterSample, now = new Date()) {
+        const prior = this.compactionAttempt(idempotencyKey);
+        if (!prior)
+            throw new Error(`compaction attempt not found: ${idempotencyKey}`);
+        if (prior.status !== "succeeded")
+            return prior;
+        this.db.prepare("UPDATE compaction_attempts SET after_sample_json=?,updated_at=? WHERE idempotency_key=?")
+            .run(json(afterSample), now.toISOString(), idempotencyKey);
+        return this.compactionAttempt(idempotencyKey);
+    }
     compactionAttempt(idempotencyKey) {
         const row = this.db.prepare("SELECT * FROM compaction_attempts WHERE idempotency_key=?").get(idempotencyKey);
         return row ? compactionAttemptFromRow(row) : undefined;
@@ -481,6 +492,25 @@ export class WorkflowDb {
     recoveryDecisions(runId) {
         return this.db.prepare("SELECT receipt_json FROM recovery_decisions WHERE run_id=? ORDER BY decision_id").all(runId).map((row) => parseJson(row.receipt_json));
     }
+    /**
+     * A process may die after dispatching a provider turn but before its durable
+     * continuity checkpoint. The provider may have compacted during that gap, so
+     * recovery must not treat that role session's compaction history as complete.
+     */
+    hasUncheckpointedRoleTurn(runId, role) {
+        const events = this.continuityEvents(runId);
+        let startSequence = 0;
+        for (const event of events) {
+            if (event.kind === "turn_started" && event.role === "host" && event.payload.role === role) {
+                startSequence = event.sequence;
+            }
+            else if (startSequence && event.sequence > startSequence
+                && (event.kind === "turn_completed" || event.kind === "turn_completed_after_repair" || event.kind === "fresh_successor_accepted")) {
+                startSequence = 0;
+            }
+        }
+        return startSequence > 0;
+    }
     beginPublication(runId, intent, previousDigests, now = new Date()) {
         const transactionId = randomUUID();
         const at = now.toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.7.7",
+  "version": "1.7.9",
   "description": "An orchestrator that keeps Codex CLI / Claude Code builders moving through their step list unattended. Part of Rafi.",
   "license": "Apache-2.0",
   "type": "module",
@@ -158,8 +158,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.148"
   },
   "dependencies": {
-    "special-agents": "0.8.5",
-    "rafi-spec": "0.8.5",
+    "special-agents": "0.8.7",
+    "rafi-spec": "0.8.7",
     "@clack/prompts": "^1.4.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",