ai-foreman 1.7.9 → 1.7.10

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.10",
   "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",