ai-foreman 1.7.8 → 1.7.10

package/dist/adapters/types.d.ts

@@ -59,55 +59,7 @@ export interface TurnResult {
     inputTokens?: number;
     outputTokens?: number;
     failure?: RuntimeFailure;
-    /** A provider turn stopped at a context-compaction boundary, not a failure. */
-    interrupted?: {
-        reason: "compaction-boundary";
-        providerEventId?: string;
-    };
 }
-export type ContextCompactionOrigin = "provider-auto" | "rafi-manual" | "recovery" | "boundary";
-export type ContextCompactionPhase = "started" | "succeeded" | "failed";
-/** Native context policy installed before a Builder/QA role may do real work. */
-export interface ContextManagementPolicy {
-    role: "builder" | "qa";
-    configuredThresholdPercent: number;
-    compactMaximum: number;
-    settingsRevision: number;
-    model: string;
-    /** Continue a provider-monotonic sequence after process recovery. */
-    providerSequenceStart?: number;
-    /** A persisted, model-matched maximum may avoid a discovery turn. */
-    knownModelContextWindow?: number;
-    /** Native compaction stays enabled until the host vetoes a boundary. */
-    nativeCompactionEnabled?: boolean;
-}
-export interface PreparedContextManagement {
-    modelContextWindow: number;
-    configuredTokenLimit: number;
-    installedNativeTokenLimit: number;
-    installedNativePercent: number;
-    sample?: ContextUsage;
-}
-export interface ContextCompactionEvent {
-    kind: "context-compaction";
-    phase: ContextCompactionPhase;
-    origin: ContextCompactionOrigin;
-    providerEventId: string;
-    providerSequence: number;
-    provider: "claude" | "codex";
-    sessionId?: string;
-    sessionRef?: ProviderSessionRefV1;
-    observedAt: string;
-    postCompactSample?: ContextUsage;
-    reason?: string;
-}
-export interface InterruptResult {
-    ok: boolean;
-    error?: string;
-    providerEventId?: string;
-}
-/** Host-owned gate used by wrappers that need additional provider turns. */
-export type ManagedTurnDispatcher = (text: string, invoke: () => Promise<TurnResult>) => Promise<TurnResult>;
 /** Observability events emitted while a builder works. */
 export type BuilderEvent = {
     kind: "text";
@@ -145,10 +97,7 @@ export type BuilderEvent = {
     percentage?: number;
     observedAt?: string;
     source?: "provider-event" | "provider-query" | "post-compact";
-    sequence?: number;
-    sessionId?: string;
-    model?: string;
-} | ContextCompactionEvent | {
+} | {
     kind: "error";
     message: string;
 };
@@ -158,10 +107,17 @@ export interface ContextUsage {
     percentage?: number;
     observedAt?: string;
     source?: "provider-event" | "provider-query" | "post-compact";
-    /** Monotonic within one scoped provider session. */
-    sequence?: number;
-    sessionId?: string;
-    model?: string;
+}
+/**
+ * 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;
@@ -177,6 +133,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;
@@ -218,8 +183,8 @@ export interface BuilderAdapterOptions {
     systemPromptAppend?: string;
     /** Skill names to preload for this session (Claude: lazy-loaded; Codex: flattened). */
     skills?: string[];
-    /** Builder/QA native policy used even for setup and handoff-acceptance turns. */
-    contextManagementPolicy?: ContextManagementPolicy;
+    /** Provider-native context ceiling, as a percentage of that provider's model window. */
+    autoCompactThresholdPercent?: number;
 }
 export interface BuilderAdapter {
     readonly agent: "claude" | "codex";
@@ -235,14 +200,20 @@ export interface BuilderAdapter {
     validateSession?(): Promise<SessionAvailabilityV1>;
     /** Provider-native compaction on the exact live conversation. */
     compact?(): Promise<CompactResult>;
-    /** Initialize the session and install native in-turn context controls. */
-    prepareContextManagement?(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    /** Safely reconfigure native in-turn controls on the same session. */
-    updateContextManagement?(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    /** Stop only at a provider-observed compaction boundary. */
-    interruptTurnAtCompactionBoundary?(providerEventId?: string): Promise<InterruptResult>;
-    /** Route wrapper-owned repair/retry/follow-up turns through the role gate. */
-    installManagedTurnDispatcher?(dispatcher: ManagedTurnDispatcher): void;
+    /**
+     * 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<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. */
+    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, ContextManagementPolicy, ContextUsage, InterruptResult, ManagedTurnDispatcher, PreparedContextManagement, 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,10 +26,11 @@ export declare class CurrentWorkflowGuardAdapter implements BuilderAdapter {
     adoptSessionRef(ref: ProviderSessionRefV1): void;
     validateSession(): Promise<SessionAvailabilityV1>;
     compact(): Promise<CompactResult>;
-    prepareContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    updateContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
-    interruptTurnAtCompactionBoundary(providerEventId?: string): Promise<InterruptResult>;
-    installManagedTurnDispatcher(dispatcher: ManagedTurnDispatcher): 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>;
     contextUsage(): Promise<ContextUsage | undefined>;
     sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;

package/dist/branch/currentGuard.js

@@ -48,12 +48,11 @@ 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; }
-    async prepareContextManagement(policy) { assertCurrentWorkflowIdentity(this.cwd, this.expected); if (!this.adapter.prepareContextManagement)
-        throw new Error("native context management unavailable"); const result = await this.adapter.prepareContextManagement(policy); assertCurrentWorkflowIdentity(this.cwd, this.expected); return result; }
-    async updateContextManagement(policy) { assertCurrentWorkflowIdentity(this.cwd, this.expected); if (!this.adapter.updateContextManagement)
-        throw new Error("native context reconfiguration unavailable"); const result = await this.adapter.updateContextManagement(policy); assertCurrentWorkflowIdentity(this.cwd, this.expected); return result; }
-    interruptTurnAtCompactionBoundary(providerEventId) { return this.adapter.interruptTurnAtCompactionBoundary?.(providerEventId) ?? Promise.resolve({ ok: false, error: "compaction-boundary interruption unavailable", providerEventId }); }
-    installManagedTurnDispatcher(dispatcher) { this.adapter.installManagedTurnDispatcher?.(dispatcher); }
+    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); }
     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)