ai-foreman 1.7.9 → 1.7.11

package/README.md

@@ -15,9 +15,9 @@ Loop Claude Code or Codex through tickets.
 - **Rich ticket system** — tickets carry acceptance criteria, required tests, dependencies, priority, size, and risk level. The agent reads the full context before starting each step.
 - **Future work tracking** — when the builder discovers out-of-scope work during a run, `ai-foreman tickets discover` captures it without derailing the current ticket. Discovered items live in a separate inbox until you promote them.
 - **QA that actually gates** — QA runs after every completed ticket and checks code quality, test passing, and regression protection. The ticket only closes after QA passes. QA turns do not count against `--steps`.
-- **Visible long-running work** — one elapsed-time activity line identifies provider, phase, tools, retries, and quiet periods; redirected output receives timestamped heartbeats instead of ANSI animation.
+- **Visible long-running work** — semantic activity rows identify provider, phase, tools, retries, and quiet periods; cursor-capable terminals update changing counters in place, while record-oriented terminals coalesce them.
 
-Provider-managed retries are reported immediately as durable lines. A quiet-provider warning appears after 60 seconds without a signal, but Foreman does not add retries, abort the provider, or change provider retry limits. Non-TTY output receives a heartbeat every 30 seconds while work remains pending.
+Provider-managed retries are reported immediately as durable lines. A quiet-provider warning appears after 60 seconds without a signal, but Foreman does not add retries, abort the provider, or change provider retry limits. Non-TTY output receives a heartbeat every 30 seconds while work remains pending. TTY rendering defaults to automatic detection: Codex, CI, and `TERM=dumb` use newline records and suppress spinner- or number-only repeats; other terminals redraw those changes in place and retain a row when the textual status changes. Use `RAFI_ACTIVITY_RENDER_MODE=auto|cursor|records` to override detection.
 
 ## Install
 
@@ -146,7 +146,7 @@ Saved `tickets.build` defaults in `rafi-config.yaml` can enable branch-per-ticke
 
 With the saved `current` strategy, Foreman works in the active branch while the user owns Git. It may edit, test, run QA, and update tracker/recovery state, but all branch/worktree, commit, push, merge, rebase, and review lifecycle commands are fenced. An unexpected active ref or worktree change pauses the run. Explicit isolated flags are reported as run overrides.
 
-The active terminal line always includes the current role/provider, activity, truthful context state, successful compaction count, and handoff generation. At the Builder threshold, Foreman settles the in-flight action, verifies native compaction plus a fresh provider usage sample, and resumes the frozen action. The configured maximum defaults to ten successful compactions per location-scoped provider session; the next crossing uses a validated fresh handoff instead of exceeding it. Disposable QA snapshots never reuse a prior QA conversation in a new `/tmp/rafi-qa-*` worktree; they transfer cumulative state through an accepted handoff.
+The current terminal status includes the role/provider, activity, truthful context state, successful compaction count, and handoff generation. At the Builder threshold, Foreman settles the in-flight action, verifies native compaction plus a fresh provider usage sample, and resumes the frozen action. The configured maximum defaults to ten successful compactions per location-scoped provider session; the next crossing uses a validated fresh handoff instead of exceeding it. Disposable QA snapshots never reuse a prior QA conversation in a new `/tmp/rafi-qa-*` worktree; they transfer cumulative state through an accepted handoff.
 
 ### GitHub PR Failure Recovery
 

package/dist/activity.d.ts

@@ -11,7 +11,10 @@ export interface ActivityReporterOptions {
     tickMs?: number;
     heartbeatMs?: number;
     quietWarningMs?: number;
+    /** Override automatic TTY capability detection for tests or embedding hosts. */
+    ttyMode?: ActivityTtyMode;
 }
+export type ActivityTtyMode = "auto" | "cursor" | "records";
 /** One process-local live view shared by nested RAFI operations. */
 export declare class ActivityReporter {
     readonly command: string;
@@ -21,6 +24,7 @@ export declare class ActivityReporter {
     private readonly tickMs;
     private readonly heartbeatMs;
     private readonly quietWarningMs;
+    private readonly ttyMode;
     private readonly commandStartedAt;
     private readonly phases;
     private nextPhaseId;
@@ -33,6 +37,7 @@ export declare class ActivityReporter {
     private quietWarningPrinted;
     private lastHeartbeatAt;
     private lineVisible;
+    private lastSemanticKey?;
     private paused;
     private agentStatusLine?;
     constructor(command: string, options?: ActivityReporterOptions);
@@ -45,7 +50,7 @@ export declare class ActivityReporter {
     pulse(detail?: string): void;
     note(message: string): void;
     writePersistent(text: string): void;
-    /** Keep role/provider/context state in the single bottom-most TTY line. */
+    /** Keep role/provider/context state attached to the current activity status. */
     setAgentStatus(line: string | undefined): void;
     pause(): () => void;
     dispose(): void;

package/dist/activity.js

@@ -10,6 +10,7 @@ export class ActivityReporter {
     tickMs;
     heartbeatMs;
     quietWarningMs;
+    ttyMode;
     commandStartedAt;
     phases = new Map();
     nextPhaseId = 1;
@@ -22,6 +23,7 @@ export class ActivityReporter {
     quietWarningPrinted = false;
     lastHeartbeatAt = 0;
     lineVisible = false;
+    lastSemanticKey;
     paused = 0;
     agentStatusLine;
     constructor(command, options = {}) {
@@ -35,6 +37,7 @@ export class ActivityReporter {
         this.tickMs = options.tickMs ?? 1_000;
         this.heartbeatMs = options.heartbeatMs ?? 30_000;
         this.quietWarningMs = options.quietWarningMs ?? 60_000;
+        this.ttyMode = resolveTtyMode(options.ttyMode);
         this.commandStartedAt = this.now();
     }
     begin(label) {
@@ -91,7 +94,7 @@ export class ActivityReporter {
             this.output.write("\n");
         this.render(true);
     }
-    /** Keep role/provider/context state in the single bottom-most TTY line. */
+    /** Keep role/provider/context state attached to the current activity status. */
     setAgentStatus(line) {
         this.agentStatusLine = line ? clean(line, 500) : undefined;
         if (this.agentStatusLine && !this.timer) {
@@ -130,7 +133,6 @@ export class ActivityReporter {
     }
     idle() {
         if (this.agentStatusLine) {
-            this.clearLine();
             this.detail = undefined;
             this.provider = undefined;
             this.model = undefined;
@@ -145,6 +147,7 @@ export class ActivityReporter {
         this.provider = undefined;
         this.model = undefined;
         this.agentStatusLine = undefined;
+        this.lastSemanticKey = undefined;
     }
     currentPhase() {
         return [...this.phases.values()].at(-1);
@@ -168,8 +171,21 @@ export class ActivityReporter {
         const body = [phase?.label, provider || undefined, phase ? quiet : undefined, this.agentStatusLine].filter(Boolean).join(" — ");
         if (this.output.isTTY) {
             const line = `${FRAMES[this.frame++ % FRAMES.length]} RAFI working: ${body} (${formatDuration(now - this.commandStartedAt)})`;
+            const semanticKey = semanticStatusKey(body);
+            if (this.ttyMode === "records") {
+                if (semanticKey === this.lastSemanticKey)
+                    return;
+                this.output.write(`${line}\n`);
+                this.lastSemanticKey = semanticKey;
+                return;
+            }
+            if (this.lineVisible && semanticKey !== this.lastSemanticKey) {
+                this.output.write("\n");
+                this.lineVisible = false;
+            }
             this.output.write(`\r\x1b[2K${line}`);
             this.lineVisible = true;
+            this.lastSemanticKey = semanticKey;
             return;
         }
         if (force || now - this.lastHeartbeatAt >= this.heartbeatMs) {
@@ -260,6 +276,27 @@ function briefInput(input) {
 function clean(value, maximum) {
     return value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim().slice(0, maximum);
 }
+function semanticStatusKey(body) {
+    return body.replace(/\p{Number}+(?:[.,]\p{Number}+)*/gu, "#");
+}
+function resolveTtyMode(requested) {
+    const configured = requested ?? configuredTtyMode(process.env.RAFI_ACTIVITY_RENDER_MODE);
+    if (configured === "cursor" || configured === "records")
+        return configured;
+    return truthyEnvironmentValue(process.env.CODEX_CI)
+        || truthyEnvironmentValue(process.env.CI)
+        || process.env.TERM?.toLowerCase() === "dumb"
+        ? "records"
+        : "cursor";
+}
+function configuredTtyMode(value) {
+    return value === "cursor" || value === "records" || value === "auto" ? value : "auto";
+}
+function truthyEnvironmentValue(value) {
+    if (value === undefined)
+        return false;
+    return !["", "0", "false"].includes(value.trim().toLowerCase());
+}
 function formatDuration(milliseconds) {
     const seconds = Math.max(0, Math.floor(milliseconds / 1_000));
     if (seconds < 60)

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, NativeCompaction, CompactResult, ContextUsage, PermissionDecision, ProviderSettingSwitch, ProviderSessionUsage, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, NativeCompaction, NativeAutoCompactionPolicy, 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()`.
@@ -57,6 +57,7 @@ export declare class ClaudeAdapter implements BuilderAdapter {
     private compactResult?;
     private autoCompactionPrepared;
     private preparedAutoCompactThreshold?;
+    private preparedAutoCompactionPolicy?;
     private manualCompactionInFlight;
     private nativeCompactions;
     private nativeCompactionSequence;
@@ -78,7 +79,8 @@ export declare class ClaudeAdapter implements BuilderAdapter {
     adoptSessionRef(ref: ProviderSessionRefV1): void;
     validateSession(): Promise<SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
-    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<void>;
+    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<NativeAutoCompactionPolicy | void>;
+    autoCompactionPolicy(): NativeAutoCompactionPolicy | undefined;
     drainNativeCompactions(): NativeCompaction[];
     restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsage(): Promise<ContextUsage | undefined>;

package/dist/adapters/claude.js

@@ -154,6 +154,7 @@ export class ClaudeAdapter {
     compactResult;
     autoCompactionPrepared = false;
     preparedAutoCompactThreshold;
+    preparedAutoCompactionPolicy;
     manualCompactionInFlight = false;
     nativeCompactions = [];
     nativeCompactionSequence = 0;
@@ -450,7 +451,7 @@ export class ClaudeAdapter {
             return;
         const threshold = validThreshold(thresholdPercent);
         if (this.autoCompactionPrepared && this.preparedAutoCompactThreshold === threshold)
-            return;
+            return this.preparedAutoCompactionPolicy;
         this.opts.autoCompactThresholdPercent = threshold;
         await this.query.initializationResult();
         await this.query.applyFlagSettings({ autoCompactEnabled: true });
@@ -469,13 +470,26 @@ export class ClaudeAdapter {
         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");
+        if (!installed.isAutoCompactEnabled || !Number.isFinite(installed.maxTokens) || installed.maxTokens <= 0
+            || !Number.isFinite(installed.autoCompactThreshold) || installed.autoCompactThreshold === undefined) {
+            throw new Error("Claude did not expose an enabled native automatic-compaction threshold after configuration");
         }
+        // `applyFlagSettings` can legitimately clamp autoCompactWindow. The
+        // provider's reported trigger is authoritative; rejecting the entire run
+        // merely because a configured value is below that minimum made defaults
+        // unusable. Lifecycle code consumes this verified effective ceiling.
+        const effectiveThresholdPercent = Math.max(1, Math.min(99, Math.floor(installed.autoCompactThreshold / installed.maxTokens * 100)));
+        this.preparedAutoCompactionPolicy = {
+            requestedThresholdPercent: threshold,
+            effectiveThresholdPercent,
+            modelContextWindow: installed.maxTokens,
+            triggerTokens: installed.autoCompactThreshold,
+        };
         this.autoCompactionPrepared = true;
         this.preparedAutoCompactThreshold = threshold;
+        return this.preparedAutoCompactionPolicy;
     }
+    autoCompactionPolicy() { return this.preparedAutoCompactionPolicy; }
     drainNativeCompactions() {
         const pending = this.nativeCompactions;
         this.nativeCompactions = [];

package/dist/adapters/codex.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, NativeAutoCompactionPolicy, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
 import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 export interface CodexLineResult {
     events: BuilderEvent[];
@@ -30,6 +30,7 @@ export declare class CodexAdapter implements BuilderAdapter {
     private nativeAutoCompactTokenLimit?;
     private autoCompactionPrepared;
     private preparedAutoCompactThreshold?;
+    private preparedAutoCompactionPolicy?;
     private nativeCompactions;
     private nativeCompactionSequence;
     private manualCompactionInFlight;
@@ -42,7 +43,8 @@ export declare class CodexAdapter implements BuilderAdapter {
     sendTurn(instruction: string): Promise<TurnResult>;
     private sendTurnInternal;
     compact(): Promise<CompactResult>;
-    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<void>;
+    prepareAutoCompaction(thresholdPercent?: number | undefined): Promise<NativeAutoCompactionPolicy | void>;
+    autoCompactionPolicy(): NativeAutoCompactionPolicy | undefined;
     drainNativeCompactions(): NativeCompaction[];
     restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsage(): Promise<ContextUsage | undefined>;

package/dist/adapters/codex.js

@@ -46,6 +46,7 @@ export class CodexAdapter {
     nativeAutoCompactTokenLimit;
     autoCompactionPrepared = false;
     preparedAutoCompactThreshold;
+    preparedAutoCompactionPolicy;
     nativeCompactions = [];
     nativeCompactionSequence = 0;
     manualCompactionInFlight = false;
@@ -181,7 +182,7 @@ export class CodexAdapter {
             return;
         const threshold = validThreshold(thresholdPercent);
         if (this.autoCompactionPrepared && this.preparedAutoCompactThreshold === threshold)
-            return;
+            return this.preparedAutoCompactionPolicy;
         this.opts.autoCompactThresholdPercent = threshold;
         await this.ensureThread();
         // Codex reports its model context window in token-usage notifications, not
@@ -205,7 +206,15 @@ export class CodexAdapter {
         await this.ensureThread();
         this.autoCompactionPrepared = true;
         this.preparedAutoCompactThreshold = threshold;
+        this.preparedAutoCompactionPolicy = {
+            requestedThresholdPercent: threshold,
+            effectiveThresholdPercent: threshold,
+            modelContextWindow: maximum,
+            triggerTokens: this.nativeAutoCompactTokenLimit,
+        };
+        return this.preparedAutoCompactionPolicy;
     }
+    autoCompactionPolicy() { return this.preparedAutoCompactionPolicy; }
     drainNativeCompactions() {
         const pending = this.nativeCompactions;
         this.nativeCompactions = [];

package/dist/adapters/recovering.d.ts

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

package/dist/adapters/recovering.js

@@ -68,6 +68,7 @@ export class RecoveringAdapter {
     }
     compact() { return this.adapter.compact?.() ?? Promise.resolve({ ok: false, error: "native compaction unavailable" }); }
     prepareAutoCompaction(thresholdPercent) { return this.adapter.prepareAutoCompaction?.(thresholdPercent) ?? Promise.resolve(); }
+    autoCompactionPolicy() { return this.adapter.autoCompactionPolicy?.(); }
     drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }

package/dist/adapters/types.d.ts

@@ -108,6 +108,17 @@ export interface ContextUsage {
     observedAt?: string;
     source?: "provider-event" | "provider-query" | "post-compact";
 }
+/**
+ * The provider-native automatic-compaction policy that was actually installed.
+ * Providers may clamp a requested ceiling to a model- or runtime-specific
+ * minimum, so lifecycle enforcement must consume the effective value.
+ */
+export interface NativeAutoCompactionPolicy {
+    requestedThresholdPercent: number;
+    effectiveThresholdPercent: number;
+    modelContextWindow?: number;
+    triggerTokens?: number;
+}
 export interface ProviderSessionUsage {
     inputTokens?: number;
     outputTokens?: number;
@@ -194,7 +205,9 @@ export interface BuilderAdapter {
      * dispatched. This intentionally happens outside a work turn so a long,
      * tool-heavy first turn is protected too.
      */
-    prepareAutoCompaction?(thresholdPercent?: number): Promise<void>;
+    prepareAutoCompaction?(thresholdPercent?: number): Promise<NativeAutoCompactionPolicy | void>;
+    /** The last provider-native automatic-compaction policy verified on this transport. */
+    autoCompactionPolicy?(): NativeAutoCompactionPolicy | undefined;
     /** Consume provider-native compactions observed since the prior drain. */
     drainNativeCompactions?(): NativeCompaction[];
     /** Return a drained batch to the adapter when durable receipt failed. */

package/dist/branch/currentGuard.d.ts

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

package/dist/branch/currentGuard.js

@@ -49,6 +49,7 @@ export class CurrentWorkflowGuardAdapter {
     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(); }
+    autoCompactionPolicy() { return this.adapter.autoCompactionPolicy?.(); }
     drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }

package/dist/cli/start.js

@@ -1959,7 +1959,12 @@ async function prepareNativeAutoCompaction(adapter) {
         throw new Error(`${adapter.agent} does not support provider-native automatic compaction`);
     }
     try {
-        await adapter.prepareAutoCompaction();
+        const policy = await adapter.prepareAutoCompaction();
+        if (policy && policy.effectiveThresholdPercent !== policy.requestedThresholdPercent) {
+            console.log(`foreman: ${adapter.agent} applied automatic compaction at ${policy.effectiveThresholdPercent}% `
+                + `(configured ${policy.requestedThresholdPercent}%; provider minimum or clamp). `
+                + "Use `rafi agents .` to update the Builder or QA saved threshold interactively.");
+        }
     }
     catch (error) {
         await adapter.close().catch(() => { });

package/dist/continuity.d.ts

@@ -1,5 +1,5 @@
 import type { ContinuityDelta, ResolvedAgentSettings } from "rafi-spec";
-import type { BuilderAdapter, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, RuntimeFailure, TurnResult } from "./adapters/types.js";
+import type { BuilderAdapter, CompactResult, ContextUsage, NativeAutoCompactionPolicy, 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,7 +70,8 @@ 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>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<NativeAutoCompactionPolicy | void>;
+    autoCompactionPolicy(): NativeAutoCompactionPolicy | undefined;
     drainNativeCompactions(): import("./adapters/types.js").NativeCompaction[];
     restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;

package/dist/continuity.js

@@ -233,6 +233,7 @@ export class ContinuityAdapter {
     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(); }
+    autoCompactionPolicy() { return this.adapter.autoCompactionPolicy?.(); }
     drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }

package/dist/sessionLifecycle.d.ts

@@ -118,6 +118,8 @@ export declare class ThresholdCompactionController {
     private crossing;
     private readonly seenSessions;
     private runOnlyThreshold?;
+    /** Verified provider ceiling. It may be higher than configured when the provider clamps. */
+    private providerEffectiveThreshold?;
     private bootstrapScheduled;
     private bootstrapRecoveryDepth;
     private historicalCountUncertain;
@@ -136,6 +138,7 @@ export declare class ThresholdCompactionController {
     private sampleFromUsage;
     private compactionCount;
     private handoffGeneration;
+    private syncProviderEffectiveThreshold;
     private threshold;
     private now;
 }

package/dist/sessionLifecycle.js

@@ -310,6 +310,8 @@ export class ThresholdCompactionController {
     crossing = 0;
     seenSessions = new Set();
     runOnlyThreshold;
+    /** Verified provider ceiling. It may be higher than configured when the provider clamps. */
+    providerEffectiveThreshold;
     bootstrapScheduled = false;
     bootstrapRecoveryDepth = 0;
     historicalCountUncertain;
@@ -320,6 +322,7 @@ export class ThresholdCompactionController {
     }
     async atSafeBoundary(adapter, frozenAction) {
         adapter = await this.adoptSettings(adapter, frozenAction);
+        this.syncProviderEffectiveThreshold(adapter);
         if (!adapter.sessionId() && !this.bootstrapScheduled) {
             this.bootstrapScheduled = true;
             const sample = {
@@ -376,6 +379,7 @@ export class ThresholdCompactionController {
         const revisionBeforeSettle = this.settings.settings_revision;
         const sessionBeforeSettle = adapterSessionKey(adapter);
         adapter = await this.adoptSettings(adapter, frozenAction);
+        this.syncProviderEffectiveThreshold(adapter);
         if (this.settings.settings_revision !== revisionBeforeSettle || adapterSessionKey(adapter) !== sessionBeforeSettle) {
             sample = await this.measure(adapter, "provider-query");
             session = adapter.sessionRef?.() ?? adapter.sessionId();
@@ -403,6 +407,7 @@ 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);
+        this.syncProviderEffectiveThreshold(adapter);
         const nativeCount = await this.observeNativeCompactions(adapter);
         const sample = await this.measure(adapter, "provider-query");
         const db = new WorkflowDb(this.options.projectDir);
@@ -657,6 +662,7 @@ export class ThresholdCompactionController {
         }
         this.settings = next;
         this.runOnlyThreshold = undefined;
+        this.syncProviderEffectiveThreshold(adoptedAdapter);
         const db = new WorkflowDb(this.options.projectDir);
         try {
             const ref = adoptedAdapter.sessionRef?.();
@@ -718,7 +724,14 @@ export class ThresholdCompactionController {
             db.close();
         }
     }
-    threshold() { return this.runOnlyThreshold ?? this.settings.auto_compact_threshold_percent ?? 50; }
+    syncProviderEffectiveThreshold(adapter) {
+        const policy = adapter.autoCompactionPolicy?.();
+        const effective = policy?.effectiveThresholdPercent;
+        this.providerEffectiveThreshold = effective !== undefined && Number.isInteger(effective) && effective >= 1 && effective <= 99
+            ? effective
+            : undefined;
+    }
+    threshold() { return this.runOnlyThreshold ?? this.providerEffectiveThreshold ?? this.settings.auto_compact_threshold_percent ?? 50; }
     now() { return this.options.now?.() ?? new Date(); }
 }
 function normalizeContextSettings(settings) {

package/dist/statusReporter.d.ts

@@ -1,5 +1,5 @@
 import type { ContextSample, SessionUsageSample } from "rafi-spec";
-import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./adapters/types.js";
+import type { BuilderAdapter, BuilderEvent, CompactResult, ContextUsage, NativeAutoCompactionPolicy, NativeCompaction, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./adapters/types.js";
 export interface AgentStatusSnapshot {
     role: "builder" | "qa";
     provider: "claude" | "codex";
@@ -82,7 +82,8 @@ 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>;
+    prepareAutoCompaction(thresholdPercent?: number): Promise<NativeAutoCompactionPolicy | void>;
+    autoCompactionPolicy(): NativeAutoCompactionPolicy | undefined;
     drainNativeCompactions(): import("./adapters/types.js").NativeCompaction[];
     restoreNativeCompactions(compactions: NativeCompaction[]): void;
     contextUsageAfterNativeCompaction(compaction: NativeCompaction): Promise<ContextUsage | undefined>;

package/dist/statusReporter.js

@@ -178,6 +178,7 @@ export class RoleStatusAdapter {
     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(); }
+    autoCompactionPolicy() { return this.adapter.autoCompactionPolicy?.(); }
     drainNativeCompactions() { return this.adapter.drainNativeCompactions?.() ?? []; }
     restoreNativeCompactions(compactions) { this.adapter.restoreNativeCompactions?.(compactions); }
     contextUsageAfterNativeCompaction(compaction) { return this.adapter.contextUsageAfterNativeCompaction?.(compaction) ?? Promise.resolve(undefined); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.7.9",
+  "version": "1.7.11",
   "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",