ai-foreman 1.7.6 → 1.7.8

package/dist/adapters/codex.d.ts

@@ -1,4 +1,5 @@
-import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
+import type { BuilderAdapter, BuilderAdapterOptions, BuilderEvent, CompactResult, ContextManagementPolicy, ContextUsage, InterruptResult, PreparedContextManagement, ProviderSessionUsage, ProviderSettingSwitch, TurnResult } from "./types.js";
+import type { ProviderSessionRefV1, SessionAvailabilityV1 } from "rafi-spec";
 export interface CodexLineResult {
     events: BuilderEvent[];
     sessionId?: string;
@@ -16,11 +17,28 @@ export declare class CodexAdapter implements BuilderAdapter {
     private pending;
     private notificationWaiters;
     private _sessionId?;
+    private _sessionRef?;
+    private sessionAvailability?;
     private initialized;
     private closed;
     private activeText;
     private usage?;
+    private usageRevision;
+    private contextSequence;
+    private providerSessionUsage?;
+    private lastTurnTokens?;
     private stderr;
+    private contextPolicy?;
+    private nativeTokenLimit?;
+    private spawnedNativeTokenLimit?;
+    private contextPrepared;
+    private setupTurnActive;
+    private setupToolAttempted;
+    private activeTurnId?;
+    private boundaryInterrupt?;
+    private compactionSequence;
+    private activeCompaction?;
+    private manualCompactionPending;
     constructor(opts: BuilderAdapterOptions);
     buildInstruction(instruction: string): string;
     buildAppServerArgs(): string[];
@@ -28,10 +46,17 @@ export declare class CodexAdapter implements BuilderAdapter {
     buildArgs(instruction: string): string[];
     sendTurn(instruction: string): Promise<TurnResult>;
     private sendTurnInternal;
+    prepareContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
+    updateContextManagement(policy: ContextManagementPolicy): Promise<PreparedContextManagement>;
+    interruptTurnAtCompactionBoundary(providerEventId?: string): Promise<InterruptResult>;
     compact(): Promise<CompactResult>;
     contextUsage(): Promise<ContextUsage | undefined>;
+    sessionUsage(): Promise<ProviderSessionUsage | undefined>;
     switchSettings(settings: ProviderSettingSwitch): Promise<CompactResult>;
     sessionId(): string | undefined;
+    sessionRef(): ProviderSessionRefV1 | undefined;
+    adoptSessionRef(ref: ProviderSessionRefV1): void;
+    validateSession(): Promise<SessionAvailabilityV1>;
     events(): AsyncIterable<BuilderEvent>;
     close(): Promise<void>;
     private ensureThread;
@@ -42,5 +67,7 @@ export declare class CodexAdapter implements BuilderAdapter {
     private handle;
     private waitFor;
     private disconnect;
+    /** Restart only app-server; the scoped thread remains the continuity boundary. */
+    private restartTransport;
     private buildSkillsAppendix;
 }

package/dist/adapters/codex.js

@@ -5,6 +5,8 @@ import { createInterface } from "node:readline";
 import { loadSkill } from "special-agents";
 import { BuilderEventQueue, withActivityPhase } from "../activity.js";
 import { normalizeRuntimeErrorText } from "../runtimeAuth.js";
+import { canonicalSessionPath, createProviderSessionRef, validateProviderSessionScope } from "../sessionIdentity.js";
+import { SessionUnavailableError, sessionUnavailableResult } from "./sessionFailure.js";
 /** Compatibility parser for recorded pre-app-server JSONL fixtures. */
 export function parseCodexLine(raw) {
     const type = raw.type;
@@ -21,6 +23,7 @@ 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;
@@ -31,20 +34,44 @@ export class CodexAdapter {
     pending = new Map();
     notificationWaiters = new Map();
     _sessionId;
+    _sessionRef;
+    sessionAvailability;
     initialized = false;
     closed = false;
     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;
     constructor(opts) {
         this.opts = opts;
-        this._sessionId = opts.resumeSessionId;
+        this._sessionId = opts.resumeSessionRef?.sessionId ?? opts.resumeSessionId;
+        this._sessionRef = opts.resumeSessionRef;
     }
     buildInstruction(instruction) {
         return [this.opts.systemPromptAppend, this.buildSkillsAppendix(), instruction]
             .filter((part) => Boolean(part)).join("\n\n");
     }
-    buildAppServerArgs() { return ["app-server", "--listen", "stdio://"]; }
+    buildAppServerArgs() {
+        const args = ["app-server", "--listen", "stdio://"];
+        if (this.nativeTokenLimit !== undefined) {
+            args.push("-c", `model_auto_compact_token_limit=${this.nativeTokenLimit}`, "-c", 'model_auto_compact_token_limit_scope="total"');
+        }
+        return args;
+    }
     /** Deprecated fixture helper. Runtime execution uses only app-server. */
     buildArgs(instruction) {
         const args = ["exec", "--json", "--skip-git-repo-check", "--sandbox", this.opts.sandboxMode ?? "workspace-write", "-C", this.opts.cwd];
@@ -60,61 +87,199 @@ 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) {
+    async sendTurnInternal(instruction, setup = false) {
         if (this.closed)
             throw new Error("builder is closed");
         this.eventQueue.push({ kind: "activity", state: "starting Codex turn", provider: "codex", model: this.opts.model });
+        let turnStartDispatched = false;
         try {
             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);
-            await this.request("turn/start", {
+            turnStartDispatched = true;
+            const started = await this.request("turn/start", {
                 threadId: this._sessionId,
-                input: [{ type: "text", text: this.buildInstruction(instruction), text_elements: [] }],
+                input: [{ type: "text", text: setup ? instruction : 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 };
+            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 });
+                this.eventQueue.push({ kind: "turn-complete", result });
+                return result;
+            }
             const detail = [error instanceof Error ? error.message : String(error), this.stderr].filter(Boolean).join("\n");
             const text = normalizeRuntimeErrorText("codex", detail, this.process?.exitCode ?? null, "builder turn");
             this.disconnect(new Error(text));
-            const result = { text, isError: true, numTurns: 1, costUsd: 0 };
+            const resumed = Boolean(this.opts.resumeSessionRef);
+            const result = resumed
+                ? sessionUnavailableResult(new SessionUnavailableError({
+                    runtime: "codex", phase: turnStartDispatched ? "turn" : "attach", dispatchState: turnStartDispatched ? "unknown" : "not-sent",
+                    executable: this.opts.runtimeExecutable ?? "codex", cwd: this.opts.cwd, diagnostics: text,
+                    availability: { version: 1, status: turnStartDispatched ? "unknown" : "unavailable", checkedAt: new Date().toISOString(), reason: turnStartDispatched ? "probe-failed" : "attach-failed", detail: text, sessionRef: this.opts.resumeSessionRef },
+                }))
+                : { text, isError: true, numTurns: 1, costUsd: 0, costAuthoritative: false };
             this.eventQueue.push({ kind: "error", message: text });
             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
+            // provider reduced the live context. The app server emits a fresh token
+            // usage notification for the compacted thread; require it alongside the
+            // explicit contextCompaction completion item.
+            this.usage = undefined;
             const done = this.waitFor("item/completed", (params) => {
                 const item = params.item;
                 return params.threadId === this._sessionId && item?.type === "contextCompaction";
-            });
-            await this.request("thread/compact/start", { threadId: this._sessionId });
-            await done;
-            this.usage = undefined;
+            }, CODEX_COMPACTION_TIMEOUT_MS);
+            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,
+            ]);
             this.eventQueue.push({ kind: "session-transition", transition: "compacted" });
             return { ok: true };
         }
         catch (error) {
+            if (error instanceof SessionUnavailableError)
+                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 contextUsage() { return this.usage; }
+    async sessionUsage() { return this.providerSessionUsage ? { ...this.providerSessionUsage } : undefined; }
     async switchSettings(settings) {
         this.opts.model = settings.model;
         this.opts.effort = settings.effort;
@@ -122,6 +287,26 @@ export class CodexAdapter {
         return { ok: true };
     }
     sessionId() { return this._sessionId; }
+    sessionRef() { return this._sessionRef; }
+    adoptSessionRef(ref) {
+        if (ref.provider !== "codex" || ref.sessionId !== this._sessionId)
+            throw new Error("cannot adopt a session reference for a different Codex thread");
+        this._sessionRef = ref;
+    }
+    async validateSession() {
+        const checkedAt = new Date().toISOString();
+        if (!this._sessionRef)
+            return { version: 1, status: "unknown", checkedAt, reason: "legacy-unscoped", detail: "Codex raw thread IDs cannot be declared exact without a stored location scope" };
+        try {
+            await this.ensureThread();
+            return this.sessionAvailability ?? { version: 1, status: "available", checkedAt, observedCwd: canonicalSessionPath(this.opts.cwd), sessionRef: this._sessionRef };
+        }
+        catch (error) {
+            if (error instanceof SessionUnavailableError && error.failure.availability)
+                return error.failure.availability;
+            return { version: 1, status: "unknown", checkedAt, reason: "probe-failed", detail: error instanceof Error ? error.message : String(error), sessionRef: this._sessionRef };
+        }
+    }
     events() { return this.eventQueue; }
     async close() {
         if (this.closed)
@@ -131,20 +316,93 @@ export class CodexAdapter {
         this.eventQueue.close();
     }
     async ensureThread() {
+        if (this._sessionRef && !this.threadAttached) {
+            if (this._sessionRef.source === "legacy-inferred") {
+                const availability = { version: 1, status: "unknown", checkedAt: new Date().toISOString(), reason: "legacy-unscoped", detail: "legacy Codex thread IDs cannot be proven exact without an observed scoped binding", sessionRef: this._sessionRef };
+                this.sessionAvailability = availability;
+                throw new SessionUnavailableError({ runtime: "codex", phase: "preflight", dispatchState: "not-sent", executable: this.opts.runtimeExecutable ?? "codex", cwd: this.opts.cwd, diagnostics: availability.detail, availability });
+            }
+            const scoped = validateProviderSessionScope(this._sessionRef, {
+                provider: "codex", cwd: this.opts.cwd, configRoot: this.opts.configRoot ?? this.opts.cwd,
+                role: this.opts.sessionRole ?? this._sessionRef.role, stream: this.opts.sessionStream ?? this._sessionRef.stream,
+                workspaceIdentity: this.opts.workspaceIdentity, ticketId: this.opts.ticketId, deliveryUnitId: this.opts.deliveryUnitId,
+            });
+            if (scoped.status !== "available" || !scoped.sessionRef) {
+                this.sessionAvailability = scoped;
+                throw new SessionUnavailableError({
+                    runtime: "codex", phase: "preflight", dispatchState: "not-sent", executable: this.opts.runtimeExecutable ?? "codex",
+                    cwd: this.opts.cwd, diagnostics: scoped.detail ?? `Codex session ${this._sessionRef.sessionId} is ${scoped.status}`, availability: scoped,
+                });
+            }
+            this._sessionRef = scoped.sessionRef;
+        }
         await this.ensureConnection();
         if (this._sessionId && this.initialized === true && this.threadAttached)
             return;
         const method = this._sessionId ? "thread/resume" : "thread/start";
-        const result = await this.request(method, {
-            ...(this._sessionId ? { threadId: this._sessionId } : {}), cwd: this.opts.cwd,
-            model: this.opts.model ?? null, approvalPolicy: "never",
-            sandbox: this.opts.sandboxMode === "read-only" ? "read-only" : "workspace-write",
-            developerInstructions: this.opts.systemPromptAppend ?? null,
-        });
+        let result;
+        try {
+            result = await this.request(method, {
+                ...(this._sessionId ? { threadId: this._sessionId } : {}), cwd: this.opts.cwd,
+                model: this.opts.model ?? null, approvalPolicy: "never",
+                sandbox: this.opts.sandboxMode === "read-only" ? "read-only" : "workspace-write",
+                developerInstructions: this.opts.systemPromptAppend ?? null,
+            });
+        }
+        catch (error) {
+            if (this._sessionRef) {
+                const detail = error instanceof Error ? error.message : String(error);
+                const availability = {
+                    version: 1, status: "unavailable", checkedAt: new Date().toISOString(),
+                    reason: /not found|unknown thread|no thread/i.test(detail) ? "not-found" : "attach-failed", detail, sessionRef: this._sessionRef,
+                };
+                this.sessionAvailability = availability;
+                throw new SessionUnavailableError({ runtime: "codex", phase: "attach", dispatchState: "not-sent", executable: this.opts.runtimeExecutable ?? "codex", cwd: this.opts.cwd, diagnostics: detail, availability, cause: error });
+            }
+            throw error;
+        }
         const thread = result.thread;
-        this._sessionId = String(thread?.id ?? this._sessionId ?? "") || undefined;
+        const returnedSessionId = String(thread?.id ?? this._sessionId ?? "") || undefined;
+        if (this._sessionRef && returnedSessionId !== this._sessionRef.sessionId) {
+            const availability = {
+                version: 1,
+                status: "unavailable",
+                checkedAt: new Date().toISOString(),
+                reason: "attach-failed",
+                detail: `Codex resumed thread ${returnedSessionId ?? "without an ID"} instead of requested thread ${this._sessionRef.sessionId}`,
+                sessionRef: this._sessionRef,
+            };
+            this.sessionAvailability = availability;
+            throw new SessionUnavailableError({
+                runtime: "codex",
+                phase: "attach",
+                dispatchState: "not-sent",
+                executable: this.opts.runtimeExecutable ?? "codex",
+                cwd: this.opts.cwd,
+                diagnostics: availability.detail,
+                availability,
+            });
+        }
+        this._sessionId = returnedSessionId;
         if (!this._sessionId)
             throw new Error(`${method} did not return a thread ID`);
+        const providerCwd = typeof thread?.cwd === "string" ? canonicalSessionPath(thread.cwd) : undefined;
+        if (this._sessionRef && providerCwd && providerCwd !== canonicalSessionPath(this._sessionRef.cwd)) {
+            const availability = { version: 1, status: "unavailable", checkedAt: new Date().toISOString(), reason: "cwd-mismatch", observedCwd: providerCwd, detail: `Codex thread cwd ${providerCwd} does not match ${this._sessionRef.cwd}`, sessionRef: this._sessionRef };
+            this.sessionAvailability = availability;
+            throw new SessionUnavailableError({ runtime: "codex", phase: "attach", dispatchState: "not-sent", executable: this.opts.runtimeExecutable ?? "codex", cwd: this.opts.cwd, diagnostics: availability.detail, availability });
+        }
+        if (!this._sessionRef) {
+            this._sessionRef = createProviderSessionRef({
+                provider: "codex", sessionId: this._sessionId, cwd: providerCwd ?? this.opts.cwd, configRoot: this.opts.configRoot ?? this.opts.cwd,
+                role: this.opts.sessionRole, stream: this.opts.sessionStream, generation: this.opts.sessionGeneration,
+                workspaceIdentity: this.opts.workspaceIdentity, ticketId: this.opts.ticketId, deliveryUnitId: this.opts.deliveryUnitId,
+            });
+        }
+        else {
+            this._sessionRef = { ...this._sessionRef, validatedAt: new Date().toISOString() };
+        }
+        this.sessionAvailability = { version: 1, status: "available", checkedAt: new Date().toISOString(), observedCwd: providerCwd ?? canonicalSessionPath(this.opts.cwd), sessionRef: this._sessionRef };
         this.threadAttached = true;
         this.eventQueue.push({ kind: "session-transition", transition: method === "thread/resume" ? "resumed" : "started" });
     }
@@ -155,6 +413,7 @@ 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.
@@ -166,8 +425,10 @@ export class CodexAdapter {
             }
             catch { /* ignore non-protocol stdout */ } });
         child.stderr.on("data", (chunk) => { this.stderr = `${this.stderr}${chunk.toString()}`.slice(-8192); });
-        child.on("error", (error) => this.disconnect(error));
-        child.on("close", (code) => this.disconnect(new Error(`Codex app-server exited with code ${code ?? "unknown"}`)));
+        child.on("error", (error) => { if (this.process === child)
+            this.disconnect(error); });
+        child.on("close", (code) => { if (this.process === child)
+            this.disconnect(new Error(`Codex app-server exited with code ${code ?? "unknown"}`)); });
         await this.request("initialize", { clientInfo: { name: "rafi", title: "Rafi", version: "1" }, capabilities: { experimentalApi: true, requestAttestation: false } });
         this.write({ method: "initialized", params: {} });
         this.initialized = true;
@@ -202,8 +463,29 @@ export class CodexAdapter {
         if (!message.method)
             return;
         const params = message.params ?? {};
-        if (message.method === "item/started") {
+        if (message.method === "turn/started") {
+            const turn = params.turn;
+            if (typeof turn?.id === "string")
+                this.activeTurnId = turn.id;
+        }
+        else 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(),
+                });
+            }
             const activity = codexItemActivity(item);
             if (activity)
                 this.eventQueue.push({ kind: "activity", provider: "codex", ...activity });
@@ -217,6 +499,21 @@ export class CodexAdapter {
             else if (item?.type === "commandExecution")
                 this.eventQueue.push({ kind: "tool", name: "command_execution", input: { command: item.command } });
             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 });
@@ -233,10 +530,30 @@ export class CodexAdapter {
         else if (message.method === "thread/tokenUsage/updated") {
             const tokenUsage = params.tokenUsage;
             const total = tokenUsage?.total;
-            const used = Number(total?.totalTokens ?? 0);
-            const maximum = Number(tokenUsage?.modelContextWindow ?? 0) || undefined;
-            this.usage = { used, maximum, ...(maximum ? { percentage: used / maximum * 100 } : {}) };
-            this.eventQueue.push({ kind: "context-usage", ...this.usage });
+            const last = tokenUsage?.last;
+            // `last` is active context occupancy. `total` is lifetime session usage.
+            const used = Number(last?.totalTokens);
+            const maximum = Number(tokenUsage?.modelContextWindow);
+            const observedAt = new Date().toISOString();
+            const totalInput = optionalNonNegative(total?.inputTokens);
+            const totalOutput = optionalNonNegative(total?.outputTokens);
+            const sessionTotal = optionalNonNegative(total?.totalTokens);
+            if (totalInput !== undefined || totalOutput !== undefined || sessionTotal !== undefined) {
+                this.providerSessionUsage = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: sessionTotal, observedAt, source: "provider" };
+            }
+            this.lastTurnTokens = {
+                inputTokens: optionalNonNegative(last?.inputTokens),
+                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.usageRevision += 1;
+                this.eventQueue.push({ kind: "context-usage", ...this.usage });
+            }
         }
         else if (message.method === "error") {
             const error = params.error;
@@ -252,8 +569,27 @@ export class CodexAdapter {
             waiter.predicate(params) ? waiter.resolve(params) : remaining.push(waiter);
         this.notificationWaiters.set(message.method, remaining);
     }
-    waitFor(method, predicate) {
-        return new Promise((resolve, reject) => { const waiters = this.notificationWaiters.get(method) ?? []; waiters.push({ predicate, resolve, reject }); this.notificationWaiters.set(method, waiters); });
+    waitFor(method, predicate, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            let timeout;
+            const waiter = {
+                predicate,
+                resolve: (params) => { if (timeout)
+                    clearTimeout(timeout); resolve(params); },
+                reject: (error) => { if (timeout)
+                    clearTimeout(timeout); reject(error); },
+            };
+            const waiters = this.notificationWaiters.get(method) ?? [];
+            waiters.push(waiter);
+            this.notificationWaiters.set(method, waiters);
+            if (timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    const active = this.notificationWaiters.get(method) ?? [];
+                    this.notificationWaiters.set(method, active.filter((candidate) => candidate !== waiter));
+                    reject(new Error(`Timed out waiting for Codex app-server notification ${method}`));
+                }, timeoutMs);
+            }
+        });
     }
     disconnect(error) {
         const child = this.process;
@@ -270,6 +606,24 @@ 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");
+        const child = this.process;
+        this.process = undefined;
+        this.initialized = false;
+        this.threadAttached = false;
+        if (child && 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)
             return undefined;
@@ -277,6 +631,23 @@ export class CodexAdapter {
         return blocks.length ? ["# Preloaded Skills", "Use the following skills for this run.", ...blocks].join("\n\n") : undefined;
     }
 }
+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 isToolItem(type) {
+    return type === "commandExecution" || type === "fileChange" || type === "mcpToolCall" || type === "dynamicToolCall" || type === "webSearch";
+}
 function activityPhase(phase) {
     if (phase === "planning")
         return "planning";