ai-foreman 1.7.8 → 1.7.10

package/dist/adapters/codex.js

@@ -23,7 +23,6 @@ export function parseCodexLine(raw) {
         return { events: [{ kind: "error", message: String(raw.error?.message ?? JSON.stringify(raw)) }] };
     return { events: [] };
 }
-const CODEX_COMPACTION_TIMEOUT_MS = 120_000;
 /** Persistent JSON-RPC controller for one live Codex thread. */
 export class CodexAdapter {
     opts;
@@ -41,21 +40,17 @@ export class CodexAdapter {
     activeText = [];
     usage;
     usageRevision = 0;
-    contextSequence = 0;
     providerSessionUsage;
     lastTurnTokens;
     stderr = "";
-    contextPolicy;
-    nativeTokenLimit;
-    spawnedNativeTokenLimit;
-    contextPrepared = false;
-    setupTurnActive = false;
-    setupToolAttempted = false;
-    activeTurnId;
-    boundaryInterrupt;
-    compactionSequence = 0;
-    activeCompaction;
-    manualCompactionPending = false;
+    nativeAutoCompactTokenLimit;
+    autoCompactionPrepared = false;
+    preparedAutoCompactThreshold;
+    preparedAutoCompactionPolicy;
+    nativeCompactions = [];
+    nativeCompactionSequence = 0;
+    manualCompactionInFlight = false;
+    observedToolCalls = 0;
     constructor(opts) {
         this.opts = opts;
         this._sessionId = opts.resumeSessionRef?.sessionId ?? opts.resumeSessionId;
@@ -67,8 +62,8 @@ export class CodexAdapter {
     }
     buildAppServerArgs() {
         const args = ["app-server", "--listen", "stdio://"];
-        if (this.nativeTokenLimit !== undefined) {
-            args.push("-c", `model_auto_compact_token_limit=${this.nativeTokenLimit}`, "-c", 'model_auto_compact_token_limit_scope="total"');
+        if (this.nativeAutoCompactTokenLimit !== undefined) {
+            args.push("-c", `model_auto_compact_token_limit=${this.nativeAutoCompactTokenLimit}`, "-c", 'model_auto_compact_token_limit_scope="total"');
         }
         return args;
     }
@@ -87,11 +82,9 @@ export class CodexAdapter {
         return args;
     }
     async sendTurn(instruction) {
-        if (this.opts.contextManagementPolicy && !this.contextPrepared)
-            await this.prepareContextManagement(this.opts.contextManagementPolicy);
         return withActivityPhase(`Codex ${activityPhase(this.opts.runtimePhase)}`, () => this.sendTurnInternal(instruction));
     }
-    async sendTurnInternal(instruction, setup = false) {
+    async sendTurnInternal(instruction) {
         if (this.closed)
             throw new Error("builder is closed");
         this.eventQueue.push({ kind: "activity", state: "starting Codex turn", provider: "codex", model: this.opts.model });
@@ -100,49 +93,29 @@ export class CodexAdapter {
             await this.ensureThread();
             this.activeText = [];
             this.lastTurnTokens = undefined;
-            this.setupTurnActive = setup;
-            this.setupToolAttempted = false;
             const completion = this.waitFor("turn/completed", (params) => params.threadId === this._sessionId);
             turnStartDispatched = true;
-            const started = await this.request("turn/start", {
+            await this.request("turn/start", {
                 threadId: this._sessionId,
-                input: [{ type: "text", text: setup ? instruction : this.buildInstruction(instruction), text_elements: [] }],
+                input: [{ type: "text", text: this.buildInstruction(instruction), text_elements: [] }],
                 cwd: this.opts.cwd,
                 model: this.opts.model ?? null,
                 effort: this.opts.effort ?? (this.opts.fast ? "low" : null),
             });
-            const startedTurn = started.turn;
-            this.activeTurnId = typeof startedTurn?.id === "string" ? startedTurn.id : undefined;
             const params = await completion;
             const turn = params.turn;
             const failed = turn?.status === "failed";
-            const interrupted = turn?.status === "interrupted" || Boolean(this.boundaryInterrupt);
             const error = turn?.error;
             const text = this.activeText.join("\n");
             const result = {
                 text: failed ? normalizeRuntimeErrorText("codex", String(error?.message ?? text), null, "app-server turn") : text,
                 isError: failed, numTurns: 1, costUsd: 0, costAuthoritative: false,
                 ...(this.lastTurnTokens ?? {}),
-                ...(interrupted ? { interrupted: { reason: "compaction-boundary", ...(this.boundaryInterrupt?.providerEventId ? { providerEventId: this.boundaryInterrupt.providerEventId } : {}) } } : {}),
             };
-            if (setup && this.setupToolAttempted)
-                throw new Error("Codex context setup attempted to invoke a tool; native context capability was not established");
             this.eventQueue.push({ kind: "turn-complete", result });
             return result;
         }
         catch (error) {
-            if (this.boundaryInterrupt) {
-                const result = {
-                    text: this.activeText.join("\n"), isError: false, numTurns: 1, costUsd: 0,
-                    costAuthoritative: false, ...(this.lastTurnTokens ?? {}),
-                    interrupted: {
-                        reason: "compaction-boundary",
-                        ...(this.boundaryInterrupt.providerEventId ? { providerEventId: this.boundaryInterrupt.providerEventId } : {}),
-                    },
-                };
-                this.eventQueue.push({ kind: "turn-complete", result });
-                return result;
-            }
             if (error instanceof SessionUnavailableError) {
                 const result = sessionUnavailableResult(error);
                 this.eventQueue.push({ kind: "error", message: result.text });
@@ -164,87 +137,10 @@ export class CodexAdapter {
             this.eventQueue.push({ kind: "turn-complete", result });
             return result;
         }
-        finally {
-            this.activeTurnId = undefined;
-            this.setupTurnActive = false;
-            this.boundaryInterrupt = undefined;
-        }
-    }
-    async prepareContextManagement(policy) {
-        validateContextPolicy(policy);
-        this.contextPolicy = { ...policy };
-        this.compactionSequence = Math.max(this.compactionSequence, policy.providerSequenceStart ?? 0);
-        this.contextSequence = Math.max(this.contextSequence, policy.providerSequenceStart ?? 0);
-        if (policy.knownModelContextWindow && policy.knownModelContextWindow > 0) {
-            this.nativeTokenLimit = tokenCeiling(policy.knownModelContextWindow, policy.configuredThresholdPercent);
-        }
-        await this.ensureThread();
-        if (!this.usage) {
-            const setup = await this.sendTurnInternal("Rafi context setup only. Do not call tools or change files. Reply with exactly CONTEXT_READY.", true);
-            if (setup.isError || setup.text.trim() !== "CONTEXT_READY") {
-                throw new Error(`Codex context setup did not complete safely: ${setup.text.slice(0, 240)}`);
-            }
-        }
-        const maximum = this.usage?.maximum ?? policy.knownModelContextWindow;
-        if (!maximum || !Number.isFinite(maximum) || maximum <= 0) {
-            throw new Error("Codex did not expose modelContextWindow during context setup");
-        }
-        const configuredTokenLimit = tokenCeiling(maximum, policy.configuredThresholdPercent);
-        this.nativeTokenLimit = configuredTokenLimit;
-        if (this.spawnedNativeTokenLimit !== configuredTokenLimit) {
-            await this.restartTransport();
-            await this.ensureThread();
-        }
-        this.contextPrepared = true;
-        return {
-            modelContextWindow: maximum,
-            configuredTokenLimit,
-            installedNativeTokenLimit: configuredTokenLimit,
-            installedNativePercent: configuredTokenLimit / maximum * 100,
-            ...(this.usage ? { sample: { ...this.usage } } : {}),
-        };
-    }
-    async updateContextManagement(policy) {
-        validateContextPolicy(policy);
-        if (this.activeTurnId)
-            throw new Error("Codex native context control can be reconfigured only after the active turn settles");
-        const maximum = this.usage?.maximum ?? policy.knownModelContextWindow;
-        if (!maximum || maximum <= 0)
-            return this.prepareContextManagement(policy);
-        this.contextPolicy = { ...policy };
-        this.compactionSequence = Math.max(this.compactionSequence, policy.providerSequenceStart ?? 0);
-        this.contextSequence = Math.max(this.contextSequence, policy.providerSequenceStart ?? 0);
-        const configuredTokenLimit = tokenCeiling(maximum, policy.configuredThresholdPercent);
-        this.nativeTokenLimit = configuredTokenLimit;
-        if (this.spawnedNativeTokenLimit !== configuredTokenLimit) {
-            await this.restartTransport();
-            await this.ensureThread();
-        }
-        return {
-            modelContextWindow: maximum,
-            configuredTokenLimit,
-            installedNativeTokenLimit: configuredTokenLimit,
-            installedNativePercent: configuredTokenLimit / maximum * 100,
-            ...(this.usage ? { sample: { ...this.usage } } : {}),
-        };
-    }
-    async interruptTurnAtCompactionBoundary(providerEventId) {
-        if (!this.activeTurnId || !this._sessionId)
-            return { ok: false, error: "no active Codex turn exists at the compaction boundary", providerEventId };
-        try {
-            this.boundaryInterrupt = { providerEventId };
-            await this.request("turn/interrupt", { threadId: this._sessionId, turnId: this.activeTurnId });
-            return { ok: true, providerEventId };
-        }
-        catch (error) {
-            this.boundaryInterrupt = undefined;
-            return { ok: false, error: error instanceof Error ? error.message : String(error), providerEventId };
-        }
     }
     async compact() {
         try {
             await this.ensureThread();
-            this.manualCompactionPending = true;
             this.eventQueue.push({ kind: "session-transition", transition: "compacting" });
             const usageRevision = this.usageRevision;
             // A pre-compaction observation must never be mistaken for proof that the
@@ -255,17 +151,23 @@ export class CodexAdapter {
             const done = this.waitFor("item/completed", (params) => {
                 const item = params.item;
                 return params.threadId === this._sessionId && item?.type === "contextCompaction";
-            }, CODEX_COMPACTION_TIMEOUT_MS);
+            }, 30_000);
             const postCompactUsage = this.waitFor("thread/tokenUsage/updated", (params) => {
                 return (params.threadId === undefined || params.threadId === this._sessionId)
                     && this.usageRevision > usageRevision
                     && this.usage !== undefined;
-            }, CODEX_COMPACTION_TIMEOUT_MS);
-            await Promise.all([
-                this.request("thread/compact/start", { threadId: this._sessionId }),
-                done,
-                postCompactUsage,
-            ]);
+            }, 30_000);
+            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 };
         }
@@ -274,11 +176,63 @@ export class CodexAdapter {
                 return { ok: false, error: error.message, failure: error.failure };
             return { ok: false, error: error instanceof Error ? error.message : String(error) };
         }
-        finally {
-            this.manualCompactionPending = false;
+    }
+    async prepareAutoCompaction(thresholdPercent = this.opts.autoCompactThresholdPercent) {
+        if (thresholdPercent === undefined)
+            return;
+        const threshold = validThreshold(thresholdPercent);
+        if (this.autoCompactionPrepared && this.preparedAutoCompactThreshold === threshold)
+            return this.preparedAutoCompactionPolicy;
+        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;
+        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 = [];
+        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;
@@ -413,7 +367,6 @@ export class CodexAdapter {
         this.stderr = "";
         const executable = this.opts.runtimeExecutable ?? "codex";
         const child = spawn(executable, this.buildAppServerArgs(), { cwd: this.opts.cwd, stdio: ["pipe", "pipe", "pipe"] });
-        this.spawnedNativeTokenLimit = this.nativeTokenLimit;
         this.process = child;
         // A short-lived server may close stdin before its stderr/exit event. The
         // close handler owns rejection so diagnostics include the complete stderr.
@@ -463,29 +416,10 @@ export class CodexAdapter {
         if (!message.method)
             return;
         const params = message.params ?? {};
-        if (message.method === "turn/started") {
-            const turn = params.turn;
-            if (typeof turn?.id === "string")
-                this.activeTurnId = turn.id;
-        }
-        else if (message.method === "item/started") {
+        if (message.method === "item/started") {
             const item = params.item;
-            if (this.setupTurnActive && item && isToolItem(item.type)) {
-                this.setupToolAttempted = true;
-                if (this.activeTurnId && this._sessionId)
-                    void this.request("turn/interrupt", { threadId: this._sessionId, turnId: this.activeTurnId }).catch(() => { });
-            }
-            if (item?.type === "contextCompaction") {
-                const providerSequence = ++this.compactionSequence;
-                const providerEventId = String(item.id ?? `codex-compaction-${providerSequence}`);
-                const origin = this.manualCompactionPending ? "rafi-manual" : "provider-auto";
-                this.activeCompaction = { providerEventId, providerSequence, origin, usageRevision: this.usageRevision };
-                this.eventQueue.push({
-                    kind: "context-compaction", phase: "started", origin, providerEventId, providerSequence,
-                    provider: "codex", sessionId: this._sessionId, sessionRef: this._sessionRef,
-                    observedAt: new Date().toISOString(),
-                });
-            }
+            if (isCodexToolItem(item))
+                this.observedToolCalls += 1;
             const activity = codexItemActivity(item);
             if (activity)
                 this.eventQueue.push({ kind: "activity", provider: "codex", ...activity });
@@ -496,24 +430,22 @@ 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 {
-                if (item?.type === "contextCompaction") {
-                    const active = this.activeCompaction;
-                    const providerSequence = active?.providerSequence ?? ++this.compactionSequence;
-                    const providerEventId = String(item.id ?? active?.providerEventId ?? `codex-compaction-${providerSequence}`);
-                    const origin = active?.origin ?? (this.manualCompactionPending ? "rafi-manual" : "provider-auto");
-                    const failed = item.status === "failed" || item.status === "error" || item.error !== undefined;
-                    this.eventQueue.push({
-                        kind: "context-compaction", phase: failed ? "failed" : "succeeded", origin, providerEventId, providerSequence,
-                        provider: "codex", sessionId: this._sessionId, sessionRef: this._sessionRef,
-                        observedAt: new Date().toISOString(),
-                        ...(failed ? { reason: String(item.error?.message ?? item.error ?? "Codex context compaction failed") } : {}),
-                        ...(!failed && this.usage && (!active || this.usageRevision > active.usageRevision) ? { postCompactSample: { ...this.usage, source: "post-compact" } } : {}),
-                    });
-                    this.activeCompaction = undefined;
-                }
                 const activity = codexItemActivity(item, true);
                 if (activity)
                     this.eventQueue.push({ kind: "activity", provider: "codex", ...activity });
@@ -531,8 +463,7 @@ export class CodexAdapter {
             const tokenUsage = params.tokenUsage;
             const total = tokenUsage?.total;
             const last = tokenUsage?.last;
-            // `last` is active context occupancy. `total` is lifetime session usage.
-            const used = Number(last?.totalTokens);
+            const used = Number(total?.totalTokens);
             const maximum = Number(tokenUsage?.modelContextWindow);
             const observedAt = new Date().toISOString();
             const totalInput = optionalNonNegative(total?.inputTokens);
@@ -546,11 +477,7 @@ export class CodexAdapter {
                 outputTokens: optionalNonNegative(last?.outputTokens),
             };
             if (Number.isFinite(used) && used >= 0 && Number.isFinite(maximum) && maximum > 0) {
-                const sequence = ++this.contextSequence;
-                this.usage = {
-                    used, maximum, percentage: used / maximum * 100, observedAt, source: "provider-event", sequence,
-                    ...(this._sessionId ? { sessionId: this._sessionId } : {}), ...(this.opts.model ? { model: this.opts.model } : {}),
-                };
+                this.usage = { used, maximum, percentage: used / maximum * 100, observedAt, source: "provider-event" };
                 this.usageRevision += 1;
                 this.eventQueue.push({ kind: "context-usage", ...this.usage });
             }
@@ -606,23 +533,15 @@ export class CodexAdapter {
                 waiter.reject(error);
         this.notificationWaiters.clear();
     }
-    /** Restart only app-server; the scoped thread remains the continuity boundary. */
-    async restartTransport() {
-        if (this.activeTurnId)
-            throw new Error("cannot restart Codex app-server while a turn is active");
+    async restartForAutoCompaction() {
         const child = this.process;
+        if (!child)
+            return;
         this.process = undefined;
         this.initialized = false;
         this.threadAttached = false;
-        if (child && child.exitCode === null)
+        if (child.exitCode === null)
             child.kill("SIGTERM");
-        for (const pending of this.pending.values())
-            pending.reject(new Error("Codex app-server restarted for context policy"));
-        this.pending.clear();
-        for (const waiters of this.notificationWaiters.values())
-            for (const waiter of waiters)
-                waiter.reject(new Error("Codex app-server restarted for context policy"));
-        this.notificationWaiters.clear();
     }
     buildSkillsAppendix() {
         if (!this.opts.skills?.length)
@@ -635,18 +554,13 @@ function optionalNonNegative(value) {
     const number = Number(value);
     return Number.isFinite(number) && number >= 0 ? number : undefined;
 }
-function tokenCeiling(maximum, percentage) {
-    return Math.max(1, Math.floor(maximum * percentage / 100));
-}
-function validateContextPolicy(policy) {
-    if (!Number.isInteger(policy.configuredThresholdPercent) || policy.configuredThresholdPercent < 1 || policy.configuredThresholdPercent > 99) {
-        throw new Error("configured context threshold must be an integer from 1 to 99");
-    }
-    if (!Number.isSafeInteger(policy.compactMaximum) || policy.compactMaximum < 1)
-        throw new Error("compact maximum must be a positive safe integer");
+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 isToolItem(type) {
-    return type === "commandExecution" || type === "fileChange" || type === "mcpToolCall" || type === "dynamicToolCall" || type === "webSearch";
+function tokenLimit(maximum, percentage) {
+    return Math.max(1, Math.floor(maximum * percentage / 100));
 }
 function activityPhase(phase) {
     if (phase === "planning")
@@ -679,6 +593,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, ContextManagementPolicy, ContextUsage, InterruptResult, ManagedTurnDispatcher, PreparedContextManagement, 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 {
@@ -21,7 +21,6 @@ export declare class RecoveringAdapter implements BuilderAdapter {
     private readonly eventQueue;
     private eventPump;
     private closed;
-    private turnDispatcher?;
     constructor(opts: RecoveringAdapterOptions);
     get agent(): "claude" | "codex";
     sendTurn(text: string): Promise<TurnResult>;
@@ -30,10 +29,11 @@ export declare class RecoveringAdapter 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("./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

@@ -9,7 +9,6 @@ export class RecoveringAdapter {
     eventQueue = new AsyncQueue();
     eventPump;
     closed = false;
-    turnDispatcher;
     constructor(opts) {
         this.opts = opts;
         this.adapter = opts.initial;
@@ -21,8 +20,7 @@ export class RecoveringAdapter {
     }
     async sendTurn(text) {
         while (true) {
-            const invoke = () => this.adapter.sendTurn(text);
-            const result = this.turnDispatcher ? await this.turnDispatcher(text, invoke) : await invoke();
+            const result = await this.adapter.sendTurn(text);
             const sessionRef = this.adapter.sessionRef?.();
             if (sessionRef && this.opts.onSessionRef) {
                 try {
@@ -69,12 +67,11 @@ 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" }); }
-    prepareContextManagement(policy) { if (!this.adapter.prepareContextManagement)
-        return Promise.reject(new Error("native context management unavailable")); return this.adapter.prepareContextManagement(policy); }
-    updateContextManagement(policy) { if (!this.adapter.updateContextManagement)
-        return Promise.reject(new Error("native context reconfiguration unavailable")); return this.adapter.updateContextManagement(policy); }
-    interruptTurnAtCompactionBoundary(providerEventId) { return this.adapter.interruptTurnAtCompactionBoundary?.(providerEventId) ?? Promise.resolve({ ok: false, error: "compaction-boundary interruption unavailable", providerEventId }); }
-    installManagedTurnDispatcher(dispatcher) { this.turnDispatcher = 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); }
     events() {