condukt 0.16.8 → 0.16.10

package/dist/runtimes/copilot/sdk-backend.js

@@ -49,9 +49,45 @@ exports.SdkBackend = void 0;
 const cp = __importStar(require("child_process"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const node_crypto_1 = require("node:crypto");
 const types_1 = require("../../src/types");
 const lifecycle_events_1 = require("./lifecycle-events");
 const subagents_1 = require("./subagents");
+// The CLI requires at least four messages before history.compact() can make
+// progress. This is a runtime constraint, not a tuned safety threshold.
+const MIN_MESSAGES_FOR_COMPACTION = 4;
+function parseContextUsage(data) {
+    if (!data)
+        return undefined;
+    const currentTokens = data.currentTokens;
+    const tokenLimit = data.tokenLimit;
+    const messagesLength = data.messagesLength;
+    if (typeof currentTokens !== 'number'
+        || !Number.isFinite(currentTokens)
+        || currentTokens < 0
+        || typeof tokenLimit !== 'number'
+        || !Number.isFinite(tokenLimit)
+        || tokenLimit <= 0
+        || typeof messagesLength !== 'number'
+        || !Number.isFinite(messagesLength)
+        || messagesLength < 0) {
+        return undefined;
+    }
+    return {
+        currentTokens,
+        tokenLimit,
+        messagesLength,
+        ...(nonNegativeFiniteNumber(data.systemTokens) !== undefined
+            ? { systemTokens: data.systemTokens }
+            : {}),
+        ...(nonNegativeFiniteNumber(data.conversationTokens) !== undefined
+            ? { conversationTokens: data.conversationTokens }
+            : {}),
+        ...(nonNegativeFiniteNumber(data.toolDefinitionsTokens) !== undefined
+            ? { toolDefinitionsTokens: data.toolDefinitionsTokens }
+            : {}),
+    };
+}
 function normalizeSdkEvent(event) {
     if (typeof event !== 'object' || event === null)
         return {};
@@ -64,15 +100,114 @@ function normalizeSdkEvent(event) {
             : {}),
     };
 }
+function isChildModelRequest(context) {
+    if (context.interactionType === 'conversation-compaction')
+        return false;
+    if (context.interactionType === 'conversation-subagent'
+        || context.interactionType === 'conversation-sampling') {
+        return true;
+    }
+    // Generic child traffic must carry both sides of its parent relationship.
+    // Treat incomplete or ambiguous provenance as parent traffic so uncertainty
+    // cannot bypass parent guards.
+    return context.agentId !== undefined && context.parentAgentId !== undefined;
+}
+function modelRequestPurpose(interactionType, child, retry) {
+    if (interactionType === 'conversation-compaction')
+        return 'compaction';
+    if (retry)
+        return 'retry';
+    return child ? 'child' : 'normal-turn';
+}
+function observedRequestBodyTelemetry(request) {
+    const contentLength = request.headers.get('content-length');
+    const parsedLength = contentLength === null ? undefined : Number(contentLength);
+    return Number.isFinite(parsedLength) && parsedLength !== undefined && parsedLength >= 0
+        ? { observedRequestBodyBytes: parsedLength }
+        : {};
+}
+function createObservedRequestHandler(RequestHandler, WebSocketForwarder, observe, usageFor, refreshParentUsage, retryState, canDispatch) {
+    return new class extends RequestHandler {
+        parentObservationTail = Promise.resolve();
+        async sendRequest(request, context) {
+            let serialized = observedRequestBodyTelemetry(request);
+            try {
+                const body = await request.clone().arrayBuffer();
+                serialized = {
+                    observedRequestBodyBytes: body.byteLength,
+                    observedRequestBodySha256: (0, node_crypto_1.createHash)('sha256')
+                        .update(new Uint8Array(body))
+                        .digest('hex'),
+                };
+            }
+            catch {
+                // A bodyless or non-cloneable request still carries content-length when known.
+            }
+            await this.observeRequest(context, serialized);
+            return super.sendRequest(request, context);
+        }
+        async openWebSocket(context) {
+            await this.observeRequest(context, {});
+            return new WebSocketForwarder(context);
+        }
+        observeRequest(context, serialized) {
+            const child = isChildModelRequest(context);
+            if (child)
+                return this.observeRequestNow(context, serialized, true);
+            const previous = this.parentObservationTail;
+            const observation = previous.then(() => this.observeRequestNow(context, serialized, false));
+            this.parentObservationTail = observation.catch(() => undefined);
+            return observation;
+        }
+        async observeRequestNow(context, serialized, child) {
+            const compaction = context.interactionType === 'conversation-compaction';
+            const retryAgentId = child ? context.agentId : undefined;
+            const retry = compaction || (child && retryAgentId === undefined)
+                ? false
+                : retryState(retryAgentId, false);
+            const purpose = modelRequestPurpose(context.interactionType, child, retry);
+            const childUsage = child && context.agentId !== undefined
+                ? usageFor(context.agentId)
+                : undefined;
+            const measurement = child
+                ? childUsage === undefined
+                    ? undefined
+                    : { usage: childUsage, observedInterRequestGrowth: 0 }
+                : await refreshParentUsage(purpose);
+            const usage = measurement?.usage;
+            observe({
+                requestId: context.requestId,
+                sessionId: context.sessionId,
+                agentId: context.agentId,
+                parentAgentId: context.parentAgentId,
+                purpose,
+                interactionType: context.interactionType,
+                currentTokens: usage?.currentTokens,
+                tokenLimit: usage?.tokenLimit,
+                messagesLength: usage?.messagesLength,
+                systemTokens: usage?.systemTokens,
+                conversationTokens: usage?.conversationTokens,
+                toolDefinitionsTokens: usage?.toolDefinitionsTokens,
+                ...serialized,
+            });
+            if (!canDispatch(context, purpose, child, measurement)) {
+                throw new Error(`Blocked ${purpose} model request ${context.requestId}: parent context headroom has not been restored`);
+            }
+            if (retry)
+                retryState(retryAgentId, true);
+        }
+    }();
+}
 const NAMED_SDK_EVENTS = new Set([
     'assistant.message', 'assistant.message_delta',
     'assistant.reasoning', 'assistant.reasoning_delta',
+    'assistant.turn_retry',
     'assistant.intent', 'assistant.usage',
     'tool.execution_start', 'tool.execution_complete',
     'tool.execution_partial_result',
     'session.idle', 'session.task_complete', 'session.error',
     'model.call_failure', 'abort',
-    'session.compaction_start', 'session.compaction_complete',
+    'session.usage_info', 'session.compaction_start', 'session.compaction_complete',
     'subagent.started', 'subagent.completed', 'subagent.failed',
     'permission.requested',
 ]);
@@ -336,6 +471,9 @@ class SdkBackend {
     mcpConfigPath;
     configDirectory;
     subagentRoster;
+    subagentsEnabled;
+    maxDepth;
+    maxConcurrency;
     extraPathDirs;
     pathTools;
     logger;
@@ -345,6 +483,9 @@ class SdkBackend {
         this.mcpConfigPath = options.mcpConfigPath;
         this.configDirectory = options.configDir;
         this.subagentRoster = options.subagentRoster;
+        this.subagentsEnabled = options.subagentsEnabled ?? true;
+        this.maxDepth = options.maxDepth;
+        this.maxConcurrency = options.maxConcurrency;
         this.extraPathDirs = options.extraPathDirs ?? [];
         this.pathTools = options.pathTools ?? [];
         this.logger = options.logger ?? types_1.NO_OP_LOGGER;
@@ -366,7 +507,7 @@ class SdkBackend {
         if (cached)
             return cached;
         const resolution = this.resolveModelCapabilitiesUncached(client, model).catch((err) => {
-            this.logger.warn('Copilot model capability resolution failed; using proportional compaction thresholds only', {
+            this.logger.warn('Copilot model capability resolution failed; awaiting runtime context accounting', {
                 model,
                 reason: 'capability_resolution_failed',
                 error: err instanceof Error ? err.message : String(err),
@@ -382,7 +523,7 @@ class SdkBackend {
             return {};
         const selected = models.find(candidate => candidate.id === model);
         if (!selected) {
-            this.logger.warn('Copilot model capability lookup failed; using proportional compaction thresholds only', {
+            this.logger.warn('Copilot model capability lookup failed; awaiting runtime context accounting', {
                 model,
                 reason: 'model_not_found',
             });
@@ -402,7 +543,7 @@ class SdkBackend {
                 ? contextWindowLimit
                 : undefined;
         if (source === undefined || discoveredLimit === undefined) {
-            this.logger.warn('Copilot model capability lookup returned no usable token limit; using proportional compaction thresholds only', {
+            this.logger.warn('Copilot model capability lookup returned no usable token limit; awaiting runtime context accounting', {
                 model,
                 reason: 'invalid_limit',
                 maxPromptTokens: promptLimit,
@@ -410,28 +551,14 @@ class SdkBackend {
             });
             return {};
         }
-        const promptTokenCeiling = Math.floor(discoveredLimit * 0.80);
-        if (!isPositiveFiniteNumber(promptTokenCeiling)) {
-            this.logger.warn('Copilot model capability lookup produced no usable prompt-token ceiling; using proportional compaction thresholds only', {
-                model,
-                reason: 'invalid_computed_ceiling',
-                discoveredLimit,
-                limitSource: source,
-            });
-            return {};
-        }
-        this.logger.info('Resolved Copilot model prompt-token ceiling', {
+        this.logger.info('Resolved Copilot model prompt-token limit', {
             model,
-            discoveredLimit,
+            reportedPromptTokenLimit: discoveredLimit,
             limitSource: source,
-            promptTokenCeiling,
         });
         return {
-            modelCapabilities: {
-                limits: {
-                    max_prompt_tokens: promptTokenCeiling,
-                },
-            },
+            reportedPromptTokenLimit: Math.floor(discoveredLimit),
+            limitSource: source,
         };
     }
     listModels(client) {
@@ -443,7 +570,7 @@ class SdkBackend {
                 return await client.listModels();
             }
             catch (err) {
-                this.logger.warn('Copilot model capability discovery failed; using proportional compaction thresholds only', {
+                this.logger.warn('Copilot model capability discovery failed; awaiting runtime context accounting', {
                     reason: 'list_models_failed',
                     error: err instanceof Error ? err.message : String(err),
                 });
@@ -456,7 +583,7 @@ class SdkBackend {
         if (options?.signal?.aborted) {
             throw new Error('Session creation aborted');
         }
-        return new SdkSession(config, this.mcpConfigPath, this.configDirectory, this.subagentRoster, this.extraPathDirs, this.pathTools, this.logger, (client, model) => this.resolveModelCapabilities(client, model));
+        return new SdkSession(config, this.mcpConfigPath, this.configDirectory, this.subagentRoster, this.subagentsEnabled, this.maxDepth, this.maxConcurrency, this.extraPathDirs, this.pathTools, this.logger, (client, model) => this.resolveModelCapabilities(client, model));
     }
 }
 exports.SdkBackend = SdkBackend;
@@ -481,6 +608,9 @@ class SdkSession {
     mcpConfigPath;
     configDirectory;
     backendRoster;
+    backendSubagentsEnabled;
+    backendMaxDepth;
+    backendMaxConcurrency;
     extraPathDirs;
     pathTools;
     logger;
@@ -490,11 +620,23 @@ class SdkSession {
     compactionTimer = null;
     abortGraceTimer = null;
     compactionInProgress = false;
+    parentCompactionGeneration = 0;
+    verifiedParentCompactionGeneration = 0;
+    compactionBaselinePromise;
+    proactiveCompactionPromise;
+    reportedPromptTokenLimit;
+    reportedPromptTokenLimitSource;
+    adaptiveCompactionPolicy;
+    previousParentRequestTokens;
+    largestObservedInterRequestGrowth = 0;
+    parentUsage;
+    latestContextDiagnostics;
+    childUsage = new Map();
+    retryingAgentIds = new Set();
+    retryingParent = false;
     turnSettled = false;
-    compactionRecoveryInProgress = false;
     aborted = false;
     _turnText = new Map();
-    intentionalAborts = new WeakSet();
     /**
      * Maps toolCallId -> toolName for attributing tool_complete events.
      * Populated from assistant.message toolRequests and tool.execution_start.
@@ -515,11 +657,56 @@ class SdkSession {
         // SDK manages the CLI process internally; no direct PID access
         return null;
     }
-    constructor(config, mcpConfigPath, configDirectory, backendRoster, extraPathDirs, pathTools, logger, resolveModelCapabilities) {
+    history = {
+        summarizeForHandoff: async () => {
+            const sdkSession = this.activeSdkSession();
+            const result = await sdkSession.rpc.history.summarizeForHandoff();
+            this.logger.info('Copilot history handoff summary completed', {
+                summaryLength: result.summary.length,
+            });
+            return result.summary;
+        },
+        truncate: async (eventId) => {
+            const sdkSession = this.activeSdkSession();
+            const result = await sdkSession.rpc.history.truncate({ eventId });
+            this.logger.warn('Copilot history truncation completed', {
+                eventId,
+                eventsRemoved: result.eventsRemoved,
+            });
+            return result.eventsRemoved;
+        },
+    };
+    metadata = {
+        getContextAttribution: async () => {
+            const result = await this.activeSdkSession().rpc.metadata.getContextAttribution();
+            return result.contextAttribution ?? null;
+        },
+        getContextHeaviestMessages: async (limit) => {
+            return this.activeSdkSession().rpc.metadata.getContextHeaviestMessages(limit === undefined ? {} : { limit });
+        },
+        recomputeContextTokens: async (modelId = this.config.model) => {
+            return this.activeSdkSession().rpc.metadata.recomputeContextTokens({ modelId });
+        },
+    };
+    usage = {
+        getMetrics: async () => {
+            return this.activeSdkSession().rpc.usage.getMetrics();
+        },
+    };
+    activeSdkSession() {
+        const sdkSession = this._sdkSession;
+        if (!sdkSession)
+            throw new Error('SDK session is not active');
+        return sdkSession;
+    }
+    constructor(config, mcpConfigPath, configDirectory, backendRoster, backendSubagentsEnabled, backendMaxDepth, backendMaxConcurrency, extraPathDirs, pathTools, logger, resolveModelCapabilities) {
         this.config = config;
         this.mcpConfigPath = mcpConfigPath;
         this.configDirectory = configDirectory;
         this.backendRoster = backendRoster;
+        this.backendSubagentsEnabled = backendSubagentsEnabled;
+        this.backendMaxDepth = backendMaxDepth;
+        this.backendMaxConcurrency = backendMaxConcurrency;
         this.extraPathDirs = extraPathDirs;
         this.pathTools = pathTools;
         this.logger = logger;
@@ -542,6 +729,16 @@ class SdkSession {
         this._toolCallNames.clear();
         this._callIdToParent.clear();
         this._pendingPartials.clear();
+        this.parentUsage = undefined;
+        this.latestContextDiagnostics = undefined;
+        this.adaptiveCompactionPolicy = undefined;
+        this.previousParentRequestTokens = undefined;
+        this.largestObservedInterRequestGrowth = 0;
+        this.childUsage.clear();
+        this.retryingAgentIds.clear();
+        this.retryingParent = false;
+        this.compactionBaselinePromise = undefined;
+        this.proactiveCompactionPromise = undefined;
         this.turnSettled = false;
         this._run(prompt).catch((err) => {
             this.fail(err instanceof Error ? err : new Error(String(err)), 'session.run');
@@ -558,7 +755,7 @@ class SdkSession {
         const sdkModuleName = '@github/copilot-sdk';
         // eslint-disable-next-line @typescript-eslint/no-implied-eval
         const dynamicImport = new Function('specifier', 'return import(specifier)');
-        const { CopilotClient, RuntimeConnection, approveAll } = await dynamicImport(sdkModuleName);
+        const { CopilotClient, CopilotRequestHandler, CopilotWebSocketForwarder, RuntimeConnection, approveAll, } = await dynamicImport(sdkModuleName);
         // ---------------------------------------------------------------
         // Build hardened environment (strip NODE_OPTIONS, extend PATH)
         // ---------------------------------------------------------------
@@ -593,6 +790,55 @@ class SdkSession {
             connection: RuntimeConnection.forStdio(),
             env,
             logLevel: 'warning',
+            requestHandler: createObservedRequestHandler(CopilotRequestHandler, CopilotWebSocketForwarder, (telemetry) => this.logModelRequest(telemetry), (agentId) => agentId ? this.childUsage.get(agentId) : this.parentUsage, (purpose) => {
+                const sdkSession = this._sdkSession;
+                return sdkSession && (purpose === 'compaction'
+                    || this.config.compactionMode === 'adaptive'
+                    || this.shouldCaptureRequestDiagnostics(purpose))
+                    ? this.refreshParentUsageBeforeRequest(sdkSession, purpose)
+                    : Promise.resolve(this.parentUsage === undefined
+                        ? undefined
+                        : { usage: this.parentUsage, observedInterRequestGrowth: 0 });
+            }, (agentId, consume) => {
+                if (agentId) {
+                    const retry = this.retryingAgentIds.has(agentId);
+                    if (retry && consume)
+                        this.retryingAgentIds.delete(agentId);
+                    return retry;
+                }
+                const retry = this.retryingParent;
+                if (retry && consume)
+                    this.retryingParent = false;
+                return retry;
+            }, 
+            // Capability discovery also uses this handler before createSession has
+            // returned a session handle. Scope the allowance to traffic that has no
+            // session provenance so a delayed createSession cannot open a parent turn.
+            (context, purpose, child, measurement) => {
+                if (this.aborted || this.turnSettled)
+                    return false;
+                if (this._sdkSession === null) {
+                    return context.sessionId === undefined && context.agentId === undefined;
+                }
+                if (child)
+                    return true;
+                const usage = measurement?.usage;
+                if (purpose === 'compaction') {
+                    return usage !== undefined && usage.currentTokens < usage.tokenLimit;
+                }
+                if (this.parentCompactionGeneration > this.verifiedParentCompactionGeneration
+                    || this.compactionInProgress)
+                    return false;
+                if (measurement === undefined)
+                    return false;
+                const measuredUsage = measurement.usage;
+                if (measuredUsage.currentTokens + measurement.observedInterRequestGrowth
+                    >= measuredUsage.tokenLimit)
+                    return false;
+                if (this.config.compactionMode !== 'adaptive')
+                    return true;
+                return this.canDispatchParentRequest(measuredUsage);
+            }),
         });
         this._client = client;
         // ---------------------------------------------------------------
@@ -617,14 +863,30 @@ class SdkSession {
         else {
             roster = this.backendRoster;
         }
-        const { modelCapabilities } = await this.resolveModelCapabilities(client, this.config.model);
+        const { reportedPromptTokenLimit, limitSource, } = await this.resolveModelCapabilities(client, this.config.model);
+        this.reportedPromptTokenLimit = reportedPromptTokenLimit;
+        this.reportedPromptTokenLimitSource = limitSource;
+        const subagentsEnabled = this.config.subagentsEnabled ?? this.backendSubagentsEnabled;
+        const permissionHandler = subagentsEnabled
+            ? approveAll
+            : (request, invocation) => {
+                const toolName = request.kind === 'custom-tool'
+                    || request.kind === 'mcp'
+                    || request.kind === 'hook'
+                    ? request.toolName
+                    : undefined;
+                if (toolName === 'task') {
+                    return {
+                        kind: 'reject',
+                        feedback: 'Model-issued sub-agent dispatch is disabled for this session.',
+                    };
+                }
+                return approveAll(request, invocation);
+            };
         const sessionConfig = {
             model: this.config.model,
             streaming: true,
-            // This applies only to the parent session. The installed SDK's subagent
-            // settings surface cannot carry a capability override to child sessions.
-            ...(modelCapabilities !== undefined ? { modelCapabilities } : {}),
-            onPermissionRequest: approveAll,
+            onPermissionRequest: permissionHandler,
             workingDirectory: this.config.cwd,
             reasoningEffort: this.config.thinkingBudget,
             ...(this.config.contextTier !== undefined
@@ -639,9 +901,12 @@ class SdkSession {
             ...(this.config.availableTools !== undefined
                 ? { availableTools: [...this.config.availableTools] }
                 : {}),
-            ...(this.config.excludedTools !== undefined
-                ? { excludedTools: [...this.config.excludedTools] }
-                : {}),
+            ...(() => {
+                const excludedTools = new Set(this.config.excludedTools ?? []);
+                if (!subagentsEnabled)
+                    excludedTools.add('task');
+                return excludedTools.size > 0 ? { excludedTools: [...excludedTools] } : {};
+            })(),
             ...(this.config.customAgents !== undefined
                 ? { customAgents: this.config.customAgents.map(toSdkCustomAgent) }
                 : {}),
@@ -661,15 +926,20 @@ class SdkSession {
             // The SDK defaults this on, so every commit an agent composes carries a
             // Co-authored-by trailer. Output should read as the repository owner's work.
             coauthorEnabled: false,
-            // Layer proportional compaction over the discovered absolute pre-send ceiling.
-            // For gpt-5.6-sol, the SDK's 1,050,000-token denominator starts background
-            // compaction at 630,000 (60%), while 80% of the provider's 922,000 prompt
-            // limit caps pre-send prompts at 737,600 before the 787,500 blocking fraction.
-            infiniteSessions: {
-                enabled: true,
-                backgroundCompactionThreshold: 0.60,
-                bufferExhaustionThreshold: 0.75,
-            },
+            // Stock documented settings are the default and do not override model
+            // capabilities. The reduced legacy thresholds remain available for
+            // comparative diagnostics; the measured adaptive controller is opt-in.
+            infiniteSessions: this.config.compactionMode === 'aggressive'
+                ? {
+                    enabled: true,
+                    backgroundCompactionThreshold: 0.60,
+                    bufferExhaustionThreshold: 0.75,
+                }
+                : {
+                    enabled: true,
+                    backgroundCompactionThreshold: 0.80,
+                    bufferExhaustionThreshold: 0.95,
+                },
             // Registered before createSession issues its RPC, closing the early-event
             // gap for session.start and *_loaded events.
             onEvent: (event) => this.handleEarlyEvent(normalizeSdkEvent(event)),
@@ -683,16 +953,23 @@ class SdkSession {
             return;
         }
         this._sdkSession = sdkSession;
+        const maxDepth = this.config.maxDepth ?? this.backendMaxDepth;
+        const maxConcurrency = this.config.maxConcurrency ?? this.backendMaxConcurrency;
+        const subagentSettings = {
+            ...(roster !== undefined && roster !== false ? { agents: roster } : {}),
+            ...(maxDepth !== undefined ? { maxDepth } : {}),
+            ...(maxConcurrency !== undefined ? { maxConcurrency } : {}),
+        };
         // Apply the live override before any prompt can dispatch a subagent.
         // This experimental RPC degrades safely if the installed CLI rejects it.
-        if (roster !== undefined && roster !== false) {
+        if (Object.keys(subagentSettings).length > 0) {
             try {
                 await sdkSession.rpc.tools.updateSubagentSettings({
-                    subagents: { agents: roster },
+                    subagents: subagentSettings,
                 });
             }
             catch (err) {
-                this.logger.warn('Failed to apply Copilot subagent roster; using default settings', {
+                this.logger.warn('Failed to apply Copilot subagent settings; using default settings', {
                     error: err instanceof Error ? err.message : String(err),
                 });
             }
@@ -722,6 +999,9 @@ class SdkSession {
         // ---------------------------------------------------------------
         // Send the prompt (fire-and-forget; events stream via handlers)
         // ---------------------------------------------------------------
+        if (this.config.compactionMode === 'adaptive'
+            && !(await this.ensureCompactionHeadroom(sdkSession, 'pre-send')))
+            return;
         await sdkSession.send({ prompt });
     }
     /**
@@ -874,7 +1154,7 @@ class SdkSession {
         });
         // --- Session idle (agent finished all work) ---
         sdkSession.on('session.idle', (e) => {
-            if (!isActive() || this.compactionRecoveryInProgress)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             if (!e.agentId)
@@ -882,22 +1162,33 @@ class SdkSession {
         });
         // --- task_complete → idle (some models fire this instead of session.idle) ---
         sdkSession.on('session.task_complete', (e) => {
-            if (!isActive() || this.compactionRecoveryInProgress)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
-            if (!e.agentId)
-                this.settleIdle();
+            if (e.agentId)
+                return;
+            if (e.data?.success === false) {
+                const fields = {
+                    eventType: e.type ?? 'session.task_complete',
+                    ...(typeof e.data.summary === 'string' ? { summary: e.data.summary } : {}),
+                };
+                this.logger.warn('Copilot task completion failed; session remains active', fields);
+                try {
+                    process.stderr.write('[SdkBackend] TASK COMPLETION FAILED; session remains active\n');
+                }
+                catch { /* closed stream */ }
+                return;
+            }
+            this.settleIdle();
         });
         // The CLI normally follows an abort event with session.idle. If that
         // terminal event is lost, fail quickly rather than waiting for heartbeat.
         sdkSession.on('abort', (e) => {
-            if (!isActive() || this.compactionRecoveryInProgress)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             if (this.logAgentScopedFailure(e))
                 return;
-            if (this.intentionalAborts.delete(sdkSession))
-                return;
             if (this.abortGraceTimer)
                 clearTimeout(this.abortGraceTimer);
             this.abortGraceTimer = setTimeout(() => {
@@ -950,7 +1241,34 @@ class SdkSession {
                 Object.assign(error, { statusCode });
             if (errorCode !== undefined)
                 Object.assign(error, { errorCode });
-            this.fail(error, 'model.call_failure', data);
+            const compactionFailed = data?.initiator === 'compaction'
+                || data?.source === 'compaction'
+                || this.compactionInProgress
+                || this.proactiveCompactionPromise !== undefined;
+            this.fail(error, compactionFailed ? 'compaction.model.call_failure' : 'model.call_failure', {
+                ...data,
+                ...(compactionFailed ? { requestPurpose: 'compaction' } : {}),
+                ...(this.parentUsage !== undefined
+                    ? {
+                        currentTokens: this.parentUsage.currentTokens,
+                        tokenLimit: this.parentUsage.tokenLimit,
+                        messagesLength: this.parentUsage.messagesLength,
+                    }
+                    : {}),
+            });
+        });
+        sdkSession.on('session.usage_info', (e) => {
+            if (!isActive())
+                return;
+            this.handleContextUsage(sdkSession, e);
+        });
+        sdkSession.on('assistant.turn_retry', (e) => {
+            if (!isActive())
+                return;
+            if (e.agentId)
+                this.retryingAgentIds.add(e.agentId);
+            else
+                this.retryingParent = true;
         });
         // --- Context compaction (infinite sessions) ---
         // During compaction the model goes silent. SUSPEND the heartbeat entirely
@@ -958,10 +1276,12 @@ class SdkSession {
         sdkSession.on('session.compaction_start', (e) => {
             if (!isActive())
                 return;
-            this.resetHeartbeat();
             if (e.agentId)
                 return;
+            this.resetHeartbeat();
             this.compactionInProgress = true;
+            this.parentCompactionGeneration += 1;
+            this.compactionBaselinePromise = this.captureContextDiagnostics(sdkSession, 'pre-compaction');
             // SUSPEND heartbeat — compaction silence is expected
             if (this.heartbeatTimer) {
                 clearTimeout(this.heartbeatTimer);
@@ -992,82 +1312,71 @@ class SdkSession {
                         return;
                     // If force-compact works, compaction_complete will fire naturally
                 }
-                catch {
-                    // Re-check guards after await
+                catch (err) {
                     if (!isActive())
                         return;
-                    try {
-                        process.stderr.write('[SdkBackend] Force compact failed — aborting + re-sending\n');
-                    }
-                    catch { /* */ }
-                    // Escalate: abort current message, then re-send to nudge model.
-                    // Uses RAW SDK abort (session stays alive), NOT this.abort() (which tears down).
-                    // SDK docs: "The session remains valid and can continue to be used for new messages."
-                    // Wait for idle after abort before sending, to avoid racing with in-flight processing.
-                    this.compactionInProgress = false;
-                    this.compactionRecoveryInProgress = true;
-                    this._turnText.clear();
-                    try {
-                        this.intentionalAborts.add(session);
-                        await session.abort();
-                        // Some SDK versions emit abort synchronously, others just after the
-                        // request resolves. Keep the marker through the settling window.
-                        if (this.abortGraceTimer) {
-                            clearTimeout(this.abortGraceTimer);
-                            this.abortGraceTimer = null;
-                        }
-                        // WeakSet entries are removed when the delayed intentional abort event
-                        // arrives. The handle itself becomes collectible after session cleanup.
-                        // Wait briefly for the abort to settle before re-sending.
-                        // The SDK resolves abort() on acknowledgement, not on idle.
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        if (!isActive())
-                            return;
-                        await session.send({ prompt: 'Continue from where you left off.' });
-                        this.compactionRecoveryInProgress = false;
-                        this.resetHeartbeat();
-                    }
-                    catch {
-                        this.compactionRecoveryInProgress = false;
-                        try {
-                            process.stderr.write('[SdkBackend] Recovery failed — restarting heartbeat as safety net\n');
-                        }
-                        catch { /* */ }
-                        this.resetHeartbeat(); // Detect if model is truly dead instead of waiting for hours-long hard timeout
-                    }
+                    const usage = this.parentUsage;
+                    const detail = err instanceof Error ? err.message : String(err);
+                    const fields = {
+                        requestPurpose: 'compaction',
+                        error: detail,
+                        ...(usage !== undefined
+                            ? {
+                                currentTokens: usage.currentTokens,
+                                tokenLimit: usage.tokenLimit,
+                                messagesLength: usage.messagesLength,
+                                systemTokens: usage.systemTokens,
+                                conversationTokens: usage.conversationTokens,
+                                toolDefinitionsTokens: usage.toolDefinitionsTokens,
+                            }
+                            : {}),
+                    };
+                    this.fail(new Error(`Compaction recovery request failed: ${detail}`), 'compaction.recovery_failure', fields);
                 }
             }, 3 * 60 * 1000);
         });
         sdkSession.on('session.compaction_complete', (e) => {
             if (!isActive())
                 return;
-            if (e.agentId) {
-                this.resetHeartbeat();
+            if (e.agentId)
                 return;
-            }
             this.compactionInProgress = false;
             if (this.compactionTimer) {
                 clearTimeout(this.compactionTimer);
                 this.compactionTimer = null;
             }
-            // Restart heartbeat — model should resume producing output
+            // Restart heartbeat while the asynchronous verification RPC runs. Any
+            // ordinary parent request remains guarded at the request-handler seam.
             this.resetHeartbeat();
             const data = e.data;
-            // Check if compaction actually succeeded
             if (data?.success === false) {
                 const errMsg = typeof data.error === 'string' ? data.error : 'unknown reason';
-                try {
-                    process.stderr.write(`[SdkBackend] Compaction failed: ${errMsg}\n`);
-                }
-                catch { /* */ }
+                const rawStatusCode = data.statusCode;
+                const statusCode = typeof rawStatusCode === 'number'
+                    ? ` (HTTP ${rawStatusCode})`
+                    : '';
+                const usage = this.parentUsage;
+                const fields = {
+                    ...data,
+                    requestPurpose: 'compaction',
+                    ...(usage !== undefined
+                        ? {
+                            currentTokens: usage.currentTokens,
+                            tokenLimit: usage.tokenLimit,
+                            messagesLength: usage.messagesLength,
+                            systemTokens: usage.systemTokens,
+                            conversationTokens: usage.conversationTokens,
+                            toolDefinitionsTokens: usage.toolDefinitionsTokens,
+                        }
+                        : {}),
+                };
+                this.fail(new Error(`Compaction model call failed${statusCode}: ${errMsg}`), 'compaction.call_failure', fields);
+                return;
             }
-            const pre = data?.preCompactionTokens;
-            const post = data?.postCompactionTokens;
-            const removed = data?.tokensRemoved;
-            const summary = pre && post
-                ? `${pre} → ${post} tokens${removed != null ? ` (saved ${removed})` : ''}`
-                : '';
-            this.emit('compaction', 'complete', summary);
+            const generation = this.parentCompactionGeneration;
+            const baselinePromise = this.compactionBaselinePromise;
+            this.compactionBaselinePromise = undefined;
+            void this.verifyCompletedCompaction(sdkSession, data, generation, baselinePromise);
         });
         // --- Subagent lifecycle ---
         // Sub-agents use their own event path (subagent_start/subagent_end).
@@ -1088,7 +1397,18 @@ class SdkSession {
             this.resetHeartbeat();
             const data = e.data;
             const name = String(data?.agentDisplayName ?? data?.agentName ?? 'agent');
+            const agentName = String(data?.agentName ?? name);
+            const model = typeof data?.model === 'string' ? data.model : undefined;
+            const totalTokens = nonNegativeFiniteNumber(data?.totalTokens);
             const toolCallId = typeof data?.toolCallId === 'string' ? data.toolCallId : '';
+            const fields = {
+                agentName,
+                model,
+                cumulativeTokensConsumed: totalTokens,
+                totalToolCalls: nonNegativeFiniteNumber(data?.totalToolCalls),
+                durationMs: nonNegativeFiniteNumber(data?.durationMs),
+            };
+            this.logger.info('Copilot sub-agent cumulative token consumption', fields);
             this.emit('subagent_end', name, { ...data, toolCallId });
         });
         sdkSession.on('subagent.failed', (e) => {
@@ -1252,6 +1572,10 @@ class SdkSession {
         // Only the pre-handle creation window is handled here.
         if (this._sdkSession)
             return;
+        if (e.type === 'session.usage_info') {
+            this.handleContextUsage(undefined, e);
+            return;
+        }
         const eventClass = (0, lifecycle_events_1.classifySdkEvent)(e.type);
         if (eventClass === 'informational')
             return;
@@ -1337,6 +1661,409 @@ class SdkSession {
             || typeof data.error === 'string'
             || (data.error != null && typeof data.error === 'object');
     }
+    canDispatchParentRequest(usage) {
+        const policy = this.adaptiveCompactionPolicy;
+        if (usage === undefined || policy === undefined) {
+            if (usage !== undefined) {
+                this.failUnsafeContext('pre-send', usage, policy, 0, 'fresh parent context accounting was unavailable at the request-handler seam');
+            }
+            else {
+                this.fail(new Error('Blocked parent model request: fresh context accounting was unavailable'), 'pre-send-context-accounting');
+            }
+            return false;
+        }
+        if (usage.currentTokens < policy.threshold)
+            return true;
+        this.failUnsafeContext('pre-send', usage, policy, 0, 'the runtime attempted a parent model request before the required adaptive headroom was restored');
+        return false;
+    }
+    async captureContextDiagnostics(sdkSession, reason) {
+        try {
+            const [attributionResult, heaviestMessages, recomputed, usageMetrics] = await Promise.all([
+                sdkSession.rpc.metadata.getContextAttribution(),
+                sdkSession.rpc.metadata.getContextHeaviestMessages({}),
+                sdkSession.rpc.metadata.recomputeContextTokens({ modelId: this.config.model }),
+                sdkSession.rpc.usage.getMetrics(),
+            ]);
+            const attribution = attributionResult.contextAttribution ?? null;
+            const fixedPromptOverhead = attribution
+                ? Math.max(0, attribution.totalTokens - recomputed.messagesTokenCount)
+                : recomputed.systemTokenCount;
+            const diagnostics = {
+                attribution,
+                heaviestMessages,
+                recomputed,
+                usageMetrics,
+                fixedPromptOverhead,
+            };
+            this.logger.info('Captured Copilot parent context diagnostics', {
+                reason,
+                successfulCompactions: attribution?.compactions.count,
+                fixedPromptOverhead,
+                contextAttribution: attribution,
+                heaviestMessages,
+                recomputedContextTokens: recomputed,
+                usageMetrics,
+            });
+            return diagnostics;
+        }
+        catch (err) {
+            this.logger.warn('Failed to capture Copilot parent context diagnostics', {
+                reason,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return undefined;
+        }
+    }
+    async measureParentUsage(sdkSession, reason) {
+        const previous = this.parentUsage;
+        try {
+            const [contextResult, diagnostics] = await Promise.all([
+                sdkSession.rpc.metadata.contextInfo({
+                    promptTokenLimit: previous?.tokenLimit ?? this.reportedPromptTokenLimit ?? 0,
+                    outputTokenLimit: 0,
+                    selectedModel: this.config.model,
+                }),
+                this.captureContextDiagnostics(sdkSession, reason),
+            ]);
+            const contextInfo = contextResult.contextInfo;
+            if (!contextInfo || !diagnostics) {
+                this.logger.warn('Copilot parent context measurement returned incomplete context information', {
+                    reason,
+                    previousCurrentTokens: previous?.currentTokens,
+                    hasContextInfo: contextInfo !== null && contextInfo !== undefined,
+                    hasDiagnostics: diagnostics !== undefined,
+                });
+                return undefined;
+            }
+            const completeDiagnostics = diagnostics;
+            this.latestContextDiagnostics = completeDiagnostics;
+            const usage = {
+                currentTokens: diagnostics.attribution?.totalTokens ?? diagnostics.recomputed.totalTokens,
+                tokenLimit: contextInfo.promptTokenLimit,
+                messagesLength: previous?.messagesLength ?? 0,
+                systemTokens: diagnostics.recomputed.systemTokenCount,
+                conversationTokens: diagnostics.recomputed.messagesTokenCount,
+                toolDefinitionsTokens: contextInfo.toolDefinitionsTokens,
+            };
+            this.parentUsage = usage;
+            this.updateAdaptiveCompactionPolicy(usage, completeDiagnostics);
+            this.logger.info('Measured Copilot parent context', {
+                reason,
+                ...usage,
+                successfulCompactions: diagnostics.attribution?.compactions.count,
+                fixedPromptOverhead: diagnostics.fixedPromptOverhead,
+                contextAttribution: diagnostics.attribution,
+                heaviestMessages: diagnostics.heaviestMessages,
+                recomputedContextTokens: diagnostics.recomputed,
+                usageMetrics: diagnostics.usageMetrics,
+                ...this.adaptivePolicyFields(),
+            });
+            return usage;
+        }
+        catch (err) {
+            this.logger.warn('Failed to measure Copilot parent context', {
+                reason,
+                error: err instanceof Error ? err.message : String(err),
+                previousCurrentTokens: previous?.currentTokens,
+            });
+            return undefined;
+        }
+    }
+    shouldCaptureRequestDiagnostics(purpose) {
+        if (purpose === 'compaction')
+            return false;
+        const usage = this.parentUsage;
+        if (!usage)
+            return true;
+        const contextInfoThreshold = this.config.compactionMode === 'aggressive'
+            ? usage.tokenLimit * 0.60
+            : usage.tokenLimit * 0.80;
+        return usage.currentTokens >= contextInfoThreshold;
+    }
+    async refreshParentUsageBeforeRequest(sdkSession, purpose) {
+        const usage = await this.measureParentUsage(sdkSession, 'pre-request');
+        if (!usage)
+            return undefined;
+        const previousRequestTokens = this.previousParentRequestTokens;
+        const observedInterRequestGrowth = previousRequestTokens === undefined
+            ? 0
+            : Math.max(0, usage.currentTokens - previousRequestTokens);
+        if (observedInterRequestGrowth > this.largestObservedInterRequestGrowth) {
+            this.largestObservedInterRequestGrowth = observedInterRequestGrowth;
+            if (this.latestContextDiagnostics) {
+                this.updateAdaptiveCompactionPolicy(usage);
+            }
+        }
+        this.previousParentRequestTokens = usage.currentTokens;
+        this.logger.info('Refreshed Copilot parent context before model request', {
+            purpose,
+            ...usage,
+            previousRequestTokens,
+            ...(previousRequestTokens === undefined ? {} : { observedInterRequestGrowth }),
+            ...this.adaptivePolicyFields(),
+        });
+        return { usage, observedInterRequestGrowth };
+    }
+    updateAdaptiveCompactionPolicy(usage, diagnostics = this.latestContextDiagnostics) {
+        const reportedLimit = this.reportedPromptTokenLimit;
+        const tokenLimit = reportedLimit === undefined
+            ? usage.tokenLimit
+            : Math.min(reportedLimit, usage.tokenLimit);
+        if (!isPositiveFiniteNumber(tokenLimit)) {
+            this.adaptiveCompactionPolicy = undefined;
+            return;
+        }
+        // Bootstrap has no tuned token seed. Prefer the SDK's source attribution so
+        // fixed context costs are separated from conversation growth. Before that
+        // diagnostic surface initializes, reserve the first exact recomputation.
+        const fixedPromptOverhead = diagnostics?.fixedPromptOverhead ?? 0;
+        const existingPolicy = this.adaptiveCompactionPolicy;
+        const bootstrapSource = existingPolicy?.bootstrapSource
+            ?? (fixedPromptOverhead > 0 ? 'context-attribution' : 'first-recomputed-request');
+        const initialBootstrapHeadroom = fixedPromptOverhead > 0
+            ? fixedPromptOverhead
+            : diagnostics?.recomputed.totalTokens ?? usage.currentTokens;
+        const bootstrapHeadroom = Math.max(existingPolicy?.bootstrapHeadroom ?? 0, initialBootstrapHeadroom);
+        const headroom = bootstrapHeadroom + this.largestObservedInterRequestGrowth;
+        this.adaptiveCompactionPolicy = {
+            tokenLimit,
+            threshold: Math.max(0, tokenLimit - headroom),
+            headroom,
+            bootstrapHeadroom,
+            bootstrapSource,
+            largestObservedInterRequestGrowth: this.largestObservedInterRequestGrowth,
+        };
+    }
+    adaptivePolicyFields() {
+        const policy = this.adaptiveCompactionPolicy;
+        return {
+            reportedPromptTokenLimit: this.reportedPromptTokenLimit,
+            reportedPromptTokenLimitSource: this.reportedPromptTokenLimitSource,
+            adaptiveCompactionThreshold: policy?.threshold,
+            adaptiveCompactionHeadroom: policy?.headroom,
+            adaptiveBootstrapHeadroom: policy?.bootstrapHeadroom,
+            adaptiveBootstrapSource: policy?.bootstrapSource,
+            largestObservedInterRequestGrowth: policy?.largestObservedInterRequestGrowth
+                ?? this.largestObservedInterRequestGrowth,
+        };
+    }
+    logModelRequest(telemetry) {
+        const fields = {
+            ...telemetry,
+            ...this.adaptivePolicyFields(),
+        };
+        this.logger.info('Copilot model request dispatch', fields);
+        try {
+            process.stderr.write(`[SdkBackend] MODEL REQUEST requestId=${telemetry.requestId} sessionId=${telemetry.sessionId ?? 'unknown'} agentId=${telemetry.agentId ?? 'parent'} parentAgentId=${telemetry.parentAgentId ?? 'none'} purpose=${telemetry.purpose} interactionType=${telemetry.interactionType ?? 'unknown'} currentTokens=${telemetry.currentTokens ?? 'unknown'} tokenLimit=${telemetry.tokenLimit ?? 'unknown'} messagesLength=${telemetry.messagesLength ?? 'unknown'} systemTokens=${telemetry.systemTokens ?? 'unknown'} conversationTokens=${telemetry.conversationTokens ?? 'unknown'} toolDefinitionsTokens=${telemetry.toolDefinitionsTokens ?? 'unknown'} adaptiveHeadroom=${this.adaptiveCompactionPolicy?.headroom ?? 'unknown'} largestInterRequestGrowth=${this.largestObservedInterRequestGrowth} observedRequestBodyBytes=${telemetry.observedRequestBodyBytes ?? 'unknown'} observedRequestBodyTokens=${telemetry.observedRequestBodyTokens ?? 'unavailable'} observedRequestBodySha256=${telemetry.observedRequestBodySha256 ?? 'unknown'}\n`);
+        }
+        catch { /* closed stream */ }
+    }
+    handleContextUsage(sdkSession, e) {
+        const usage = parseContextUsage(e.data);
+        if (!usage) {
+            this.logger.warn('Copilot context usage event was missing valid accounting fields', {
+                agentId: e.agentId,
+                data: e.data,
+            });
+            return;
+        }
+        if (e.agentId) {
+            this.childUsage.set(e.agentId, usage);
+        }
+        else {
+            this.parentUsage = usage;
+            if (this.latestContextDiagnostics) {
+                this.updateAdaptiveCompactionPolicy(usage);
+            }
+        }
+        const fields = {
+            agentId: e.agentId,
+            ...usage,
+            ...(!e.agentId ? this.adaptivePolicyFields() : {}),
+        };
+        const scope = e.agentId ? `subagent:${e.agentId}` : 'parent';
+        this.logger.info(e.agentId ? 'Copilot sub-agent context usage' : 'Copilot parent context usage', fields);
+        try {
+            process.stderr.write(`[SdkBackend] CONTEXT USAGE scope=${scope} currentTokens=${usage.currentTokens} tokenLimit=${usage.tokenLimit} messagesLength=${usage.messagesLength} systemTokens=${usage.systemTokens ?? 'unknown'} conversationTokens=${usage.conversationTokens ?? 'unknown'} toolDefinitionsTokens=${usage.toolDefinitionsTokens ?? 'unknown'} ceiling=${!e.agentId ? this.adaptiveCompactionPolicy?.threshold ?? 'unknown' : 'isolated'} headroom=${!e.agentId ? this.adaptiveCompactionPolicy?.headroom ?? 'unknown' : 'isolated'}\n`);
+        }
+        catch { /* closed stream */ }
+        if (e.agentId)
+            return;
+        const policy = this.adaptiveCompactionPolicy;
+        if (this.config.compactionMode === 'adaptive'
+            && sdkSession
+            && policy
+            && usage.currentTokens >= policy.threshold) {
+            void this.ensureCompactionHeadroom(sdkSession, 'usage-threshold');
+        }
+    }
+    ensureCompactionHeadroom(sdkSession, source) {
+        if (this.proactiveCompactionPromise)
+            return this.proactiveCompactionPromise;
+        const policy = this.adaptiveCompactionPolicy;
+        const usage = this.parentUsage;
+        if (policy === undefined
+            || usage === undefined
+            || usage.currentTokens < policy.threshold) {
+            return Promise.resolve(true);
+        }
+        const compaction = this.compactForHeadroom(sdkSession, source, usage, policy);
+        this.proactiveCompactionPromise = compaction;
+        void compaction.then(() => {
+            if (this.proactiveCompactionPromise === compaction) {
+                this.proactiveCompactionPromise = undefined;
+            }
+        });
+        return compaction;
+    }
+    async compactForHeadroom(sdkSession, source, before, policy) {
+        if (this.aborted || this.turnSettled || this._sdkSession !== sdkSession)
+            return false;
+        if (before.messagesLength < MIN_MESSAGES_FOR_COMPACTION) {
+            return this.failUnsafeContext(source, before, policy, 0, `only ${before.messagesLength} messages are present; the CLI requires ${MIN_MESSAGES_FOR_COMPACTION}, so the latest oversized context addition cannot be compacted`);
+        }
+        this.logger.warn('Copilot parent context crossed the adaptive compaction ceiling', {
+            source,
+            ...before,
+            ...this.adaptivePolicyFields(),
+        });
+        try {
+            const beforeDiagnostics = await this.captureContextDiagnostics(sdkSession, 'pre-compaction');
+            const result = await sdkSession.rpc.history.compact();
+            if (this.aborted || this.turnSettled || this._sdkSession !== sdkSession)
+                return false;
+            const afterUsage = await this.measureParentUsage(sdkSession, 'post-compaction');
+            const afterDiagnostics = this.latestContextDiagnostics;
+            if (!result.success || !beforeDiagnostics || !afterUsage || !afterDiagnostics) {
+                return this.failUnsafeContext(source, afterUsage ?? before, policy, result.tokensRemoved, result.success
+                    ? 'the compaction result could not be verified with exact token recomputation and attribution counts'
+                    : 'the history compaction RPC reported failure');
+            }
+            const beforeCompactions = beforeDiagnostics.attribution?.compactions.count;
+            const afterCompactions = afterDiagnostics.attribution?.compactions.count;
+            const afterPolicy = this.adaptiveCompactionPolicy ?? policy;
+            this.logger.info('Verified Copilot parent context compaction', {
+                source,
+                beforeTokens: beforeDiagnostics.recomputed.totalTokens,
+                afterTokens: afterDiagnostics.recomputed.totalTokens,
+                beforeSuccessfulCompactions: beforeCompactions,
+                afterSuccessfulCompactions: afterCompactions,
+                tokensRemoved: result.tokensRemoved,
+                messagesRemoved: result.messagesRemoved,
+                messagesLength: afterUsage.messagesLength,
+                contextAttribution: afterDiagnostics.attribution,
+                heaviestMessages: afterDiagnostics.heaviestMessages,
+                usageMetrics: afterDiagnostics.usageMetrics,
+                ...this.adaptivePolicyFields(),
+            });
+            if (beforeCompactions === undefined
+                || afterCompactions === undefined
+                || afterCompactions <= beforeCompactions) {
+                return this.failUnsafeContext(source, afterUsage, afterPolicy, result.tokensRemoved, 'the successful compaction count did not advance');
+            }
+            if (afterDiagnostics.recomputed.totalTokens >= beforeDiagnostics.recomputed.totalTokens) {
+                return this.failUnsafeContext(source, afterUsage, afterPolicy, result.tokensRemoved, 'exact token recomputation did not decrease after compaction; automatic truncation is unsafe without a caller-approved history boundary');
+            }
+            if (afterUsage.currentTokens >= afterPolicy.threshold) {
+                return this.failUnsafeContext(source, afterUsage, afterPolicy, result.tokensRemoved, 'verified compaction reduced the context but did not restore the required adaptive headroom; automatic truncation is unsafe without a caller-approved history boundary');
+            }
+            return true;
+        }
+        catch (err) {
+            if (this.aborted || this.turnSettled || this._sdkSession !== sdkSession)
+                return false;
+            return this.failUnsafeContext(source, before, policy, 0, `history compaction RPC failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async verifyCompletedCompaction(sdkSession, data, generation, baselinePromise) {
+        const beforeUsage = this.parentUsage;
+        const beforeDiagnostics = await baselinePromise;
+        const after = await this.measureParentUsage(sdkSession, 'post-compaction');
+        if (this.aborted
+            || this.turnSettled
+            || this._sdkSession !== sdkSession
+            || generation !== this.parentCompactionGeneration)
+            return;
+        const afterDiagnostics = this.latestContextDiagnostics;
+        const policy = this.adaptiveCompactionPolicy;
+        const beforeCompactions = beforeDiagnostics?.attribution?.compactions.count;
+        const afterCompactions = afterDiagnostics?.attribution?.compactions.count;
+        if (!beforeUsage
+            || !after
+            || !beforeDiagnostics
+            || !afterDiagnostics
+            || beforeCompactions === undefined
+            || afterCompactions === undefined) {
+            const usage = after ?? beforeUsage;
+            if (usage) {
+                this.failUnsafeContext('compaction-complete', usage, policy, nonNegativeFiniteNumber(data?.tokensRemoved) ?? 0, 'successful compaction could not be verified with exact token recomputation and attribution counts');
+            }
+            else {
+                this.fail(new Error('Successful compaction could not be re-measured'), 'compaction.verification_failure', data);
+            }
+            return;
+        }
+        if (afterCompactions <= beforeCompactions) {
+            this.failUnsafeContext('compaction-complete', after, policy, nonNegativeFiniteNumber(data?.tokensRemoved) ?? 0, 'the successful compaction count did not advance');
+            return;
+        }
+        if (afterDiagnostics.recomputed.totalTokens >= beforeDiagnostics.recomputed.totalTokens) {
+            this.failUnsafeContext('compaction-complete', after, policy, nonNegativeFiniteNumber(data?.tokensRemoved) ?? 0, 'exact token recomputation did not decrease after compaction');
+            return;
+        }
+        if (this.config.compactionMode === 'adaptive'
+            && policy
+            && after.currentTokens >= policy.threshold) {
+            this.failUnsafeContext('compaction-complete', after, policy, nonNegativeFiniteNumber(data?.tokensRemoved) ?? 0, 'successful compaction did not restore the required adaptive headroom');
+            return;
+        }
+        const pre = nonNegativeFiniteNumber(data?.preCompactionTokens);
+        const post = nonNegativeFiniteNumber(data?.postCompactionTokens);
+        const removed = nonNegativeFiniteNumber(data?.tokensRemoved);
+        this.logger.info('Verified completed Copilot parent compaction', {
+            eventPreCompactionTokens: pre,
+            eventPostCompactionTokens: post,
+            measuredPreCompactionTokens: beforeDiagnostics.recomputed.totalTokens,
+            measuredPostCompactionTokens: afterDiagnostics.recomputed.totalTokens,
+            beforeSuccessfulCompactions: beforeCompactions,
+            afterSuccessfulCompactions: afterCompactions,
+            tokensRemoved: removed,
+            contextAttribution: afterDiagnostics.attribution,
+            heaviestMessages: afterDiagnostics.heaviestMessages,
+            ...this.adaptivePolicyFields(),
+        });
+        const summary = `${beforeDiagnostics.recomputed.totalTokens} → ${afterDiagnostics.recomputed.totalTokens} exact tokens (compactions ${beforeCompactions} → ${afterCompactions})`;
+        this.verifiedParentCompactionGeneration = generation;
+        this.emit('compaction', 'complete', summary);
+    }
+    failUnsafeContext(source, usage, policy, tokensRemoved, reason) {
+        const fields = {
+            source,
+            currentTokens: usage.currentTokens,
+            tokenLimit: policy?.tokenLimit ?? usage.tokenLimit,
+            adaptiveCompactionThreshold: policy?.threshold,
+            adaptiveCompactionHeadroom: policy?.headroom,
+            adaptiveBootstrapHeadroom: policy?.bootstrapHeadroom,
+            adaptiveBootstrapSource: policy?.bootstrapSource,
+            largestObservedInterRequestGrowth: policy?.largestObservedInterRequestGrowth
+                ?? this.largestObservedInterRequestGrowth,
+            tokensRemoved,
+            messagesLength: usage.messagesLength,
+            systemTokens: usage.systemTokens,
+            conversationTokens: usage.conversationTokens,
+            toolDefinitionsTokens: usage.toolDefinitionsTokens,
+            reason,
+        };
+        const message = `Unsafe parent context: currentTokens=${usage.currentTokens}, tokenLimit=${fields.tokenLimit}, ceiling=${policy?.threshold ?? 'unknown'}, headroom=${policy?.headroom ?? 'unknown'}, tokensRemoved=${tokensRemoved}, messagesLength=${usage.messagesLength}; ${reason}`;
+        this.logger.error('Copilot parent context could not be compacted safely', fields);
+        try {
+            process.stderr.write(`[SdkBackend] ADAPTIVE COMPACTION TERMINAL: ${message}\n`);
+        }
+        catch { /* closed stream */ }
+        this.fail(new Error(message), 'adaptive-compaction', fields);
+        return false;
+    }
     async resolvePendingRequest(sdkSession, e) {
         if (this.aborted || this._sdkSession !== sdkSession)
             return;
@@ -1404,7 +2131,10 @@ class SdkSession {
             this.abortGraceTimer = null;
         }
         this.compactionInProgress = false;
-        this.compactionRecoveryInProgress = false;
+        this.parentCompactionGeneration = 0;
+        this.verifiedParentCompactionGeneration = 0;
+        this.compactionBaselinePromise = undefined;
+        this.proactiveCompactionPromise = undefined;
     }
 }
 //# sourceMappingURL=sdk-backend.js.map