@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/agentHostChatDebugProvider.js

@@ -1,9 +1,11 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
@@ -11,17 +13,23 @@ import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
 import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { isCustomizationEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement';
 import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
-import { buildDefaultChatUri, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { buildDefaultChatUri, StateComponents, readUsageInfoMeta } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
-import { ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
+import { ChatDebugLogLevel, ChatDebugHookResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
 import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
-import { AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
-import { resolveEventsUri, COPILOT_CLI_LOCAL_AH_SCHEME, getCopilotCliSessionRawId, COPILOT_CLI_EH_SCHEME } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+import { IAgentHostCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service';
+import { AgentHostAgentDebugLogEnabledSettingId, AgentHostAgentDebugLogMaxEventsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { resolveEventsUri, COPILOT_CLI_LOCAL_AH_SCHEME, getCopilotCliSessionRawId, COPILOT_CLI_EH_SCHEME, buildLocalSessionStateUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+import { AgentHostUsageRecorder, AgentHostCustomizationRecorder, buildAgentHostUsageUri, readAgentHostUsageRecords, buildAgentHostCustomizationsUri, readAgentHostCustomizationsSnapshot } from './agentHostUsageSidecar.js';
+import { CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 
 const MAX_DISCOVERED_SESSIONS = 30;
 const TITLE_READ_BYTES = 64 * 1024;
 const MAX_RESOLVED_DETAILS = 50_000;
+const DEFAULT_MAX_EVENTS_IN_MEMORY = 10_000;
 const MAX_EVENT_PAYLOAD = 4_000;
 const MAX_DETAIL_PAYLOAD = 100_000;
 let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extends Disposable {
@@ -35,7 +43,9 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         _remoteAgentHostService,
         _agentHostService,
         _configurationService,
-        _logService
+        _logService,
+        _environmentService,
+        _customizationService
     ) {
         super();
         this._chatDebugService = _chatDebugService;
@@ -45,34 +55,72 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         this._agentHostService = _agentHostService;
         this._configurationService = _configurationService;
         this._logService = _logService;
+        this._environmentService = _environmentService;
+        this._customizationService = _customizationService;
         this._resolved = ( new Map());
         this._discovering = false;
+        this._hasFetchedOnce = false;
         this._liveRefresh = this._register(( new MutableDisposable()));
         const provider = {
             provideChatDebugLog: (sessionResource, token) => this._provideChatDebugLog(sessionResource, token),
             resolveChatDebugLogEvent: async eventId => this._resolved.get(eventId)
         };
         this._register(this._chatDebugService.registerProvider(provider));
+        this._register(( new AgentHostUsageRecorder(
+            this._environmentService.userRoamingDataHome,
+            () => this._configurationService.getValue(AgentHostAgentDebugLogEnabledSettingId),
+            this._fileService,
+            this._logService,
+            this._agentHostService,
+            this._remoteAgentHostService
+        )));
+        this._register(( new AgentHostCustomizationRecorder(
+            this._environmentService.userRoamingDataHome,
+            () => this._configurationService.getValue(AgentHostAgentDebugLogEnabledSettingId),
+            this._fileService,
+            this._logService,
+            this._agentHostService,
+            this._remoteAgentHostService
+        )));
         this._register(this._chatDebugService.onDidEndSession(sessionResource => {
             if (( sessionResource.toString()) === this._watchedSessionKey) {
                 this._liveRefresh.clear();
                 this._watchedSessionKey = undefined;
+                this._liveRead = undefined;
+                this._usageRead = undefined;
             }
         }));
-        this._maybeDiscoverLocalSessions();
+        this._register(
+            this._chatDebugService.registerAvailableSessionsFetcher(token => this._fetchLocalSessions(token))
+        );
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING)) {
+            if (e.affectsConfiguration(AgentHostAgentDebugLogEnabledSettingId) && this._hasFetchedOnce) {
                 this._maybeDiscoverLocalSessions();
             }
         }));
     }
+    async _fetchLocalSessions(token) {
+        this._hasFetchedOnce = true;
+        if (!this._configurationService.getValue(AgentHostAgentDebugLogEnabledSettingId)) {
+            return [];
+        }
+        try {
+            return await this._discoverLocalSessions(token);
+        } catch (err) {
+            this._logService.warn(`[AgentHostChatDebug] session discovery failed: ${toErrorMessage(err)}`);
+            return [];
+        }
+    }
     async _maybeDiscoverLocalSessions() {
-        if (this._discovering || !this._configurationService.getValue(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING)) {
+        if (this._discovering || !this._configurationService.getValue(AgentHostAgentDebugLogEnabledSettingId)) {
             return;
         }
         this._discovering = true;
         try {
-            await this._discoverLocalSessions();
+            const sessions = await this._discoverLocalSessions(CancellationToken.None);
+            if (sessions.length > 0) {
+                this._chatDebugService.addAvailableSessionResources(sessions);
+            }
         } catch (err) {
             this._logService.warn(`[AgentHostChatDebug] session discovery failed: ${toErrorMessage(err)}`);
         } finally {
@@ -102,13 +150,16 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         }
         this._watchedSessionKey = key;
         const store = ( new DisposableStore());
-        const scheduler = store.add(( new RunOnceScheduler(() => this._chatDebugService.invokeProviders(sessionResource), 400)));
-        const watcher = store.add(this._fileService.createWatcher(eventsUri, {
+        const scheduler = store.add(( new RunOnceScheduler(() => {
+            this._chatDebugService.invokeProviders(sessionResource);
+        }, 400)));
+        const watcher = store.add(this._fileService.createWatcher(dirname(eventsUri), {
             recursive: false,
             excludes: []
         }));
         store.add(watcher.onDidChange(e => {
-            if (e.affects(eventsUri)) {
+            const affects = e.affects(eventsUri);
+            if (affects) {
                 scheduler.schedule();
             }
         }));
@@ -116,6 +167,9 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         if (liveSub) {
             store.add(liveSub.onDidChange(() => scheduler.schedule()));
         }
+        store.add(
+            this._customizationService.onDidChangeCustomizations(() => scheduler.schedule())
+        );
         this._liveRefresh.value = store;
     }
     _sessionChatSubscription(sessionResource) {
@@ -140,27 +194,73 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         }
         return sumChatStateUsage(chat);
     }
+    async _readUsageRecords(sessionResource) {
+        const rawId = getCopilotCliSessionRawId(sessionResource);
+        if (!rawId) {
+            return undefined;
+        }
+        const uri = buildAgentHostUsageUri(this._environmentService.userRoamingDataHome, rawId);
+        const key = ( uri.toString());
+        let size;
+        try {
+            const stat = await this._fileService.stat(uri);
+            size = stat.size ?? 0;
+        } catch {
+            this._usageRead = undefined;
+            return undefined;
+        }
+        if (this._usageRead?.key === key && this._usageRead.size === size) {
+            return this._usageRead.records.length > 0 ? this._usageRead.records : undefined;
+        }
+        const records = await readAgentHostUsageRecords(this._fileService, uri);
+        this._usageRead = {
+            key,
+            size,
+            records
+        };
+        return records.length > 0 ? records : undefined;
+    }
+    async _readCustomizationsSnapshot(sessionResource) {
+        const rawId = getCopilotCliSessionRawId(sessionResource);
+        if (!rawId) {
+            return undefined;
+        }
+        const uri = buildAgentHostCustomizationsUri(this._environmentService.userRoamingDataHome, rawId);
+        const snapshot = await readAgentHostCustomizationsSnapshot(this._fileService, uri);
+        return snapshot && snapshot.length > 0 ? snapshot : undefined;
+    }
     async _provideChatDebugLog(sessionResource, token) {
+        if (!this._configurationService.getValue(AgentHostAgentDebugLogEnabledSettingId)) {
+            return undefined;
+        }
         const eventsUri = this._resolveEventsUri(sessionResource);
         if (!eventsUri) {
             return undefined;
         }
-        let text;
-        try {
-            const content = await this._fileService.readFile(eventsUri);
-            text = ( content.value.toString());
-        } catch {
+        this._ensureLiveRefresh(sessionResource, eventsUri);
+        const records = await this._readEventRecords(eventsUri, token);
+        if (records === undefined) {
             return undefined;
         }
         if (token.isCancellationRequested) {
             return undefined;
         }
-        this._ensureLiveRefresh(sessionResource, eventsUri);
         const liveUsageTotals = this._getLiveUsageTotals(sessionResource);
+        const usageRecords = await this._readUsageRecords(sessionResource);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        let customizations = this._customizationService.getCustomizations(sessionResource);
+        if (customizations.length === 0) {
+            customizations = (await this._readCustomizationsSnapshot(sessionResource)) ?? customizations;
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+        }
         const {
             events,
             resolved
-        } = convertAgentHostEventsToDebugEvents(parseJsonl(text), sessionResource, liveUsageTotals);
+        } = convertAgentHostEventsToDebugEvents(records, sessionResource, liveUsageTotals, usageRecords, customizations);
         for (const [id, detail] of resolved) {
             this._resolved.set(id, detail);
             if (this._resolved.size > MAX_RESOLVED_DETAILS) {
@@ -172,18 +272,98 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
         }
         return events;
     }
-    async _discoverLocalSessions() {
+    _maxRecordsInMemory() {
+        const configured = this._configurationService.getValue(AgentHostAgentDebugLogMaxEventsSettingId);
+        if (typeof configured === "number" && Number.isFinite(configured) && configured >= 1) {
+            return Math.floor(configured);
+        }
+        return DEFAULT_MAX_EVENTS_IN_MEMORY;
+    }
+    _capRecordsInMemory(records) {
+        const max = this._maxRecordsInMemory();
+        if (records.length > max) {
+            records.splice(0, records.length - max);
+        }
+    }
+    async _readEventRecords(eventsUri, token) {
+        const key = ( eventsUri.toString());
+        let size;
+        try {
+            const stat = await this._fileService.stat(eventsUri);
+            size = stat.size ?? 0;
+        } catch {
+            this._liveRead = undefined;
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const cache = this._liveRead?.key === key ? this._liveRead : undefined;
+        if (cache && size >= cache.consumedBytes) {
+            if (size === cache.consumedBytes) {
+                return cache.records;
+            }
+            try {
+                const content = await this._fileService.readFile(eventsUri, {
+                    position: cache.consumedBytes,
+                    length: size - cache.consumedBytes
+                });
+                if (token.isCancellationRequested) {
+                    return undefined;
+                }
+                const combined = cache.pendingBytes.byteLength ? VSBuffer.concat([cache.pendingBytes, content.value]) : content.value;
+                const lastNewline = lastIndexOfNewline(combined);
+                if (lastNewline >= 0) {
+                    appendJsonlRecords(( combined.slice(0, lastNewline + 1).toString()), cache.records);
+                    cache.pendingBytes = combined.slice(lastNewline + 1);
+                } else {
+                    cache.pendingBytes = combined;
+                }
+                cache.consumedBytes = size;
+                this._capRecordsInMemory(cache.records);
+                return cache.records;
+            } catch {}
+        }
+        let buffer;
+        try {
+            const content = await this._fileService.readFile(eventsUri);
+            buffer = content.value;
+        } catch {
+            this._liveRead = undefined;
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const lastNewline = lastIndexOfNewline(buffer);
+        const records = [];
+        if (lastNewline >= 0) {
+            appendJsonlRecords(( buffer.slice(0, lastNewline + 1).toString()), records);
+        }
+        this._capRecordsInMemory(records);
+        this._liveRead = {
+            key,
+            consumedBytes: buffer.byteLength,
+            pendingBytes: lastNewline >= 0 ? buffer.slice(lastNewline + 1) : buffer,
+            records
+        };
+        return records;
+    }
+    async _discoverLocalSessions(token) {
         const userHome = this._pathService.userHome({
             preferLocal: true
         });
-        const sessionStateDir = joinPath(userHome, ".copilot", "session-state");
+        const sessionStateDir = buildLocalSessionStateUri(userHome);
         let stat;
         try {
             stat = await this._fileService.resolve(sessionStateDir, {
                 resolveMetadata: true
             });
         } catch {
-            return;
+            return [];
+        }
+        if (token.isCancellationRequested) {
+            return [];
         }
         const folders = (stat.children ?? []).filter(child => child.isDirectory).sort((a, b) => b.mtime - a.mtime).slice(0, MAX_DISCOVERED_SESSIONS);
         const found = await Promise.all(( folders.map(async folder => {
@@ -205,16 +385,25 @@ let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extend
                 title
             };
         })));
-        const sessions = found.filter(s => s !== undefined);
-        if (sessions.length > 0) {
-            this._chatDebugService.addAvailableSessionResources(sessions);
+        if (token.isCancellationRequested) {
+            return [];
         }
+        return found.filter(s => s !== undefined);
     }
 };
-AgentHostChatDebugContribution = ( __decorate([( __param(0, IChatDebugService)), ( __param(1, IFileService)), ( __param(2, IPathService)), ( __param(3, IRemoteAgentHostService)), ( __param(4, IAgentHostService)), ( __param(5, IConfigurationService)), ( __param(6, ILogService))], AgentHostChatDebugContribution));
-function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackUsageTotals) {
+AgentHostChatDebugContribution = ( __decorate([( __param(0, IChatDebugService)), ( __param(1, IFileService)), ( __param(2, IPathService)), ( __param(3, IRemoteAgentHostService)), ( __param(4, IAgentHostService)), ( __param(5, IConfigurationService)), ( __param(6, ILogService)), ( __param(7, IWorkbenchEnvironmentService)), ( __param(8, IAgentHostCustomizationService))], AgentHostChatDebugContribution));
+function convertAgentHostEventsToDebugEvents(
+    records,
+    sessionResource,
+    fallbackUsageTotals,
+    usageRecords,
+    customizations
+) {
     const completeByToolCallId = ( new Map());
     const turnStartByTurnId = ( new Map());
+    const hookEndByInvocationId = ( new Map());
+    const permissionCompleteByRequestId = ( new Map());
+    const subagentCompleteByToolCallId = ( new Map());
     for (const record of records) {
         if (record.type === "tool.execution_complete") {
             const toolCallId = asString(record.data.toolCallId);
@@ -226,33 +415,65 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
             if (turnId) {
                 turnStartByTurnId.set(turnId, record);
             }
+        } else if (record.type === "hook.end") {
+            const invocationId = asString(record.data.hookInvocationId);
+            if (invocationId) {
+                hookEndByInvocationId.set(invocationId, record);
+            }
+        } else if (record.type === "permission.completed") {
+            const requestId = asString(record.data.requestId);
+            if (requestId) {
+                permissionCompleteByRequestId.set(requestId, record);
+            }
+        } else if (record.type === "subagent.completed") {
+            const toolCallId = asString(record.data.toolCallId);
+            if (toolCallId) {
+                subagentCompleteByToolCallId.set(toolCallId, record);
+            }
         }
     }
     const events = [];
     const resolved = ( new Map());
     const modelTurnRefs = [];
     let rootEventId;
+    let rootCreated;
     const currentUserMessageByAgent = ( new Map());
     const currentAssistantMessageByAgent = ( new Map());
     const toolEventByToolCallId = ( new Map());
+    const hasConfiguredHooks = !!customizations && ( flattenCustomizations(customizations).some(c => c.type === CustomizationType.Hook && c.enabled));
     for (const record of records) {
         const created = ( new Date(record.timestamp));
         const agentKey = record.agentId ?? "";
+        const turnParent = currentAssistantMessageByAgent.get(agentKey) ?? currentUserMessageByAgent.get(agentKey) ?? rootEventId;
         switch (record.type) {
         case "session.start":
             {
                 rootEventId = record.id;
+                rootCreated = created;
                 const model = asString(record.data.selectedModel);
                 const effort = asString(record.data.reasoningEffort);
-                const details = model ? (effort ? ( localize(6516, "model={0}, reasoningEffort={1}", model, effort)) : ( localize(6517, "model={0}", model))) : undefined;
+                const version = asString(record.data.copilotVersion);
+                const context = asRecord(record.data.context);
+                const repository = asString(context?.repository);
+                const branch = asString(context?.branch);
+                const parts = [];
+                if (model) {
+                    parts.push(effort ? ( localize(7525, "model={0}, reasoningEffort={1}", model, effort)) : ( localize(7526, "model={0}", model)));
+                }
+                if (version) {
+                    parts.push(( localize(7527, "CLI {0}", version)));
+                }
+                if (repository) {
+                    parts.push(branch ? ( localize(7528, "{0}@{1}", repository, branch)) : repository);
+                }
                 events.push({
                     kind: "generic",
                     id: record.id,
                     sessionResource,
                     created,
                     parentEventId: undefined,
-                    name: ( localize(6518, "Session Started")),
-                    details,
+                    name: ( localize(7529, "Session Started")),
+                    details: parts.length ? parts.join(", ") : undefined,
                     level: ChatDebugLogLevel.Info,
                     category: "session"
                 });
@@ -263,12 +484,12 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
                 const content = asString(record.data.content) ?? "";
                 const transformed = asString(record.data.transformedContent);
                 const sections = [{
-                    name: ( localize(6519, "User Request")),
+                    name: ( localize(7530, "User Request")),
                     content
                 }];
                 if (transformed && transformed !== content) {
                     sections.push({
-                        name: ( localize(6520, "Full Prompt")),
+                        name: ( localize(7531, "Full Prompt")),
                         content: transformed
                     });
                 }
@@ -308,6 +529,7 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
                 modelTurnRefs.push({
                     index: events.length,
                     id: record.id,
+                    turnId,
                     outputTokens
                 });
                 events.push({
@@ -324,13 +546,13 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
                 const sections = [];
                 if (content) {
                     sections.push({
-                        name: ( localize(6521, "Response")),
+                        name: ( localize(7532, "Response")),
                         content
                     });
                 }
                 if (reasoning) {
                     sections.push({
-                        name: ( localize(6522, "Reasoning")),
+                        name: ( localize(7533, "Reasoning")),
                         content: reasoning
                     });
                 }
@@ -383,16 +605,295 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
                 });
                 break;
             }
+        case "session.error":
+            {
+                const message = asString(record.data.message) ?? ( localize(7534, "Unknown error"));
+                const errorType = asString(record.data.errorType);
+                const stack = asString(record.data.stack);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: errorType ? ( localize(7535, "Error ({0})", errorType)) : ( localize(7536, "Error")),
+                    details: truncate(message, MAX_EVENT_PAYLOAD),
+                    level: ChatDebugLogLevel.Error,
+                    category: "session"
+                });
+                const detailText = stack ? `${message}\n\n${stack}` : message;
+                resolved.set(record.id, {
+                    kind: "text",
+                    value: truncate(detailText, MAX_DETAIL_PAYLOAD) ?? detailText
+                });
+                break;
+            }
+        case "session.warning":
+            {
+                const message = asString(record.data.message) ?? "";
+                const warningType = asString(record.data.warningType);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: warningType ? ( localize(7537, "Warning ({0})", warningType)) : ( localize(7538, "Warning")),
+                    details: truncate(message, MAX_EVENT_PAYLOAD),
+                    level: ChatDebugLogLevel.Warning,
+                    category: "session"
+                });
+                if (message) {
+                    resolved.set(record.id, {
+                        kind: "text",
+                        value: truncate(message, MAX_DETAIL_PAYLOAD) ?? message
+                    });
+                }
+                break;
+            }
+        case "session.model_change":
+            {
+                const previousModel = asString(record.data.previousModel);
+                const newModel = asString(record.data.newModel);
+                const effort = asString(record.data.reasoningEffort);
+                const change = previousModel && newModel ? ( localize(7539, "{0} → {1}", previousModel, newModel)) : newModel;
+                const details = change && effort ? ( localize(7540, "{0} (reasoningEffort={1})", change, effort)) : change;
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: ( localize(7541, "Model Changed")),
+                    details,
+                    level: ChatDebugLogLevel.Info,
+                    category: "session"
+                });
+                break;
+            }
+        case "hook.start":
+            {
+                const hookType = asString(record.data.hookType) ?? "hook";
+                const invocationId = asString(record.data.hookInvocationId);
+                const end = invocationId ? hookEndByInvocationId.get(invocationId) : undefined;
+                const success = end ? asBoolean(end.data.success) : undefined;
+                const isError = hookType === "errorOccurred";
+                if ((hookType === "preToolUse" || hookType === "postToolUse") && !hasConfiguredHooks) {
+                    break;
+                }
+                const hookParent = hookType === "preToolUse" ? (currentUserMessageByAgent.get(agentKey) ?? rootEventId) : turnParent;
+                if (!isError && success !== false) {
+                    events.push({
+                        kind: "generic",
+                        id: record.id,
+                        sessionResource,
+                        created,
+                        parentEventId: hookParent,
+                        name: ( localize(7542, "Hook: {0}", hookType)),
+                        level: ChatDebugLogLevel.Info,
+                        category: "hook"
+                    });
+                    const routineInput = stringifyPayload(record.data.input);
+                    resolved.set(record.id, {
+                        kind: "hook",
+                        hookType,
+                        result: success === undefined ? undefined : (success ? ChatDebugHookResult.Success : ChatDebugHookResult.Error),
+                        input: truncate(routineInput, MAX_DETAIL_PAYLOAD)
+                    });
+                    break;
+                }
+                const input = asRecord(record.data.input);
+                const errorContext = asString(input?.errorContext);
+                const recoverable = asBoolean(input?.recoverable);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: hookParent,
+                    name: isError ? (errorContext ? ( localize(7543, "Error During {0}", errorContext)) : ( localize(7544, "Error Occurred"))) : ( localize(7545, "Hook Failed: {0}", hookType)),
+                    details: isError && recoverable !== undefined ? (recoverable ? ( localize(7546, "Recoverable; retrying")) : ( localize(7547, "Unrecoverable"))) : undefined,
+                    level: isError ? (recoverable === false ? ChatDebugLogLevel.Error : ChatDebugLogLevel.Warning) : ChatDebugLogLevel.Error,
+                    category: "hook"
+                });
+                const inputText = stringifyPayload(record.data.input);
+                const endError = asRecord(end?.data.error);
+                const errorParts = endError ? [asString(endError.message), asString(endError.source)].filter(s => !!s) : [];
+                const outputText = end && end.data.output !== undefined ? stringifyPayload(end.data.output) : undefined;
+                resolved.set(record.id, {
+                    kind: "hook",
+                    hookType,
+                    result: success === undefined ? undefined : (success ? ChatDebugHookResult.Success : ChatDebugHookResult.Error),
+                    input: truncate(inputText, MAX_DETAIL_PAYLOAD),
+                    output: outputText ? truncate(outputText, MAX_DETAIL_PAYLOAD) : undefined,
+                    errorMessage: errorParts.length > 0 ? truncate(errorParts.join("\n"), MAX_DETAIL_PAYLOAD) : undefined
+                });
+                break;
+            }
+        case "permission.requested":
+            {
+                const requestId = asString(record.data.requestId);
+                const permissionRequest = asRecord(record.data.permissionRequest);
+                const kind = asString(permissionRequest?.kind) ?? "permission";
+                const intention = asString(permissionRequest?.intention);
+                const toolCallId = asString(permissionRequest?.toolCallId);
+                const completed = requestId ? permissionCompleteByRequestId.get(requestId) : undefined;
+                const resultKind = completed ? asString(asRecord(completed.data.result)?.kind) : undefined;
+                if (resultKind === "approved") {
+                    break;
+                }
+                const parentEventId = (toolCallId ? toolEventByToolCallId.get(toolCallId) : undefined) ?? turnParent;
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId,
+                    name: resultKind ? ( localize(7548, "Permission {0}: {1}", resultKind, kind)) : ( localize(7549, "Awaiting Permission: {0}", kind)),
+                    details: intention,
+                    level: ChatDebugLogLevel.Warning,
+                    category: "permission"
+                });
+                const path = asString(permissionRequest?.path);
+                const lines = [( localize(7550, "kind: {0}", kind)), intention ? ( localize(7551, "intention: {0}", intention)) : undefined, path ? ( localize(7552, "path: {0}", path)) : undefined, ( localize(7553, "result: {0}", resultKind ?? ( localize(7554, "pending"))))].filter(l => !!l);
+                resolved.set(record.id, {
+                    kind: "text",
+                    value: lines.join("\n")
+                });
+                break;
+            }
+        case "subagent.started":
+            {
+                const toolCallId = asString(record.data.toolCallId);
+                const agentName = asString(record.data.agentDisplayName) ?? asString(record.data.agentName) ?? "subagent";
+                const description = asString(record.data.agentDescription);
+                const model = asString(record.data.model);
+                const complete = toolCallId ? subagentCompleteByToolCallId.get(toolCallId) : undefined;
+                const toolCallCount = complete ? asNumber(complete.data.totalToolCalls) : undefined;
+                const totalTokens = complete ? asNumber(complete.data.totalTokens) : undefined;
+                const durationInMillis = complete ? asNumber(complete.data.durationMs) : undefined;
+                const parentEventId = (toolCallId ? toolEventByToolCallId.get(toolCallId) : undefined) ?? turnParent;
+                events.push({
+                    kind: "subagentInvocation",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId,
+                    agentName,
+                    description,
+                    status: complete ? "completed" : "running",
+                    toolCallCount,
+                    durationInMillis
+                });
+                const lines = [( localize(7555, "agent: {0}", agentName)), model ? ( localize(7556, "model: {0}", model)) : undefined, toolCallCount !== undefined ? ( localize(7557, "tool calls: {0}", toolCallCount)) : undefined, totalTokens !== undefined ? ( localize(7558, "tokens: {0}", totalTokens)) : undefined, description ? `\n${description}` : undefined].filter(l => !!l);
+                resolved.set(record.id, {
+                    kind: "text",
+                    value: lines.join("\n")
+                });
+                break;
+            }
+        case "session.compaction_start":
+            {
+                const systemTokens = asNumber(record.data.systemTokens) ?? 0;
+                const conversationTokens = asNumber(record.data.conversationTokens) ?? 0;
+                const toolTokens = asNumber(record.data.toolDefinitionsTokens) ?? 0;
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: ( localize(7559, "Context Compaction")),
+                    details: ( localize(
+                        7560,
+                        "system={0}, conversation={1}, tools={2} tokens",
+                        systemTokens,
+                        conversationTokens,
+                        toolTokens
+                    )),
+                    level: ChatDebugLogLevel.Info,
+                    category: "session"
+                });
+                break;
+            }
+        case "session.compaction_complete":
+            {
+                if (asBoolean(record.data.success) !== false) {
+                    break;
+                }
+                const error = asString(record.data.error);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: ( localize(7561, "Context Compaction Failed")),
+                    details: truncate(error, MAX_EVENT_PAYLOAD),
+                    level: ChatDebugLogLevel.Error,
+                    category: "session"
+                });
+                if (error) {
+                    resolved.set(record.id, {
+                        kind: "text",
+                        value: truncate(error, MAX_DETAIL_PAYLOAD) ?? error
+                    });
+                }
+                break;
+            }
+        case "abort":
+            {
+                const reason = asString(record.data.reason);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: ( localize(7562, "Aborted")),
+                    details: reason,
+                    level: ChatDebugLogLevel.Warning,
+                    category: "session"
+                });
+                break;
+            }
+        case "skill.invoked":
+            {
+                const name = asString(record.data.name) ?? "skill";
+                const trigger = asString(record.data.trigger);
+                const source = asString(record.data.pluginName) ?? asString(record.data.source);
+                const content = asString(record.data.content);
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: turnParent,
+                    name: ( localize(7563, "Skill Invoked: {0}", name)),
+                    details: [trigger, source].filter(Boolean).join(" · ") || undefined,
+                    level: ChatDebugLogLevel.Info,
+                    category: "customization"
+                });
+                if (content) {
+                    resolved.set(record.id, {
+                        kind: "text",
+                        value: truncate(content, MAX_DETAIL_PAYLOAD) ?? content
+                    });
+                }
+                break;
+            }
         }
     }
-    const totals = extractSessionUsageTotals(records) ?? fallbackUsageTotals;
-    if (totals && modelTurnRefs.length > 0) {
-        const n = modelTurnRefs.length;
+    const fillTurnsWithTotals = (targets, totals) => {
+        const n = targets.length;
+        if (n === 0) {
+            return;
+        }
         const inputs = totals.inputTokens !== undefined ? distributeEvenly(totals.inputTokens, n) : undefined;
         const cached = totals.cacheReadTokens !== undefined ? distributeEvenly(totals.cacheReadTokens, n) : undefined;
         const aiu = distributeEvenly(totals.totalNanoAiu, n);
         for (let i = 0; i < n; i++) {
-            const ref = modelTurnRefs[i];
+            const ref = targets[i];
             const turn = events[ref.index];
             const inputTokens = inputs?.[i];
             const cachedTokens = cached?.[i];
@@ -415,12 +916,276 @@ function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackU
                 });
             }
         }
+    };
+    if (usageRecords && usageRecords.length > 0 && modelTurnRefs.length > 0) {
+        const coverage = applyPerTurnUsage(events, resolved, modelTurnRefs, usageRecords);
+        const uncovered = modelTurnRefs.filter((_ref, i) => !( coverage.covered.has(i)));
+        if (uncovered.length > 0) {
+            const totals = extractSessionUsageTotals(records) ?? fallbackUsageTotals;
+            if (totals) {
+                fillTurnsWithTotals(uncovered, {
+                    inputTokens: totals.inputTokens !== undefined ? Math.max(0, totals.inputTokens - coverage.assignedInput) : undefined,
+                    cacheReadTokens: totals.cacheReadTokens !== undefined ? Math.max(0, totals.cacheReadTokens - coverage.assignedCache) : undefined,
+                    totalNanoAiu: Math.max(0, totals.totalNanoAiu - coverage.assignedAiu)
+                });
+            }
+        }
+    } else if (modelTurnRefs.length > 0) {
+        const totals = extractSessionUsageTotals(records) ?? fallbackUsageTotals;
+        if (totals) {
+            fillTurnsWithTotals(modelTurnRefs, totals);
+        }
+    }
+    if (customizations && customizations.length > 0) {
+        const created = rootCreated ?? (records.length > 0 ? ( new Date(records[0].timestamp)) : ( new Date()));
+        const {
+            events: customEvents,
+            resolved: customResolved
+        } = buildCustomizationDebugEvents(customizations, sessionResource, rootEventId, created);
+        events.push(...customEvents);
+        for (const [id, detail] of customResolved) {
+            resolved.set(id, detail);
+        }
+    }
+    return {
+        events,
+        resolved
+    };
+}
+const CUSTOMIZATION_TYPE_ORDER = [
+    CustomizationType.Skill,
+    CustomizationType.Hook,
+    CustomizationType.Agent,
+    CustomizationType.McpServer,
+    CustomizationType.Rule,
+    CustomizationType.Prompt
+];
+function flattenCustomizations(customizations) {
+    const out = [];
+    const visit = c => {
+        if (c.type === CustomizationType.Plugin || c.type === CustomizationType.Directory) {
+            for (const child of c.children ?? []) {
+                visit(child);
+            }
+            return;
+        }
+        out.push({
+            type: c.type,
+            name: c.name,
+            uri: c.uri,
+            enabled: c.type === CustomizationType.McpServer ? isCustomizationEnabled(c) : c.enabled !== false,
+            description: c.description
+        });
+    };
+    for (const c of customizations) {
+        visit(c);
+    }
+    return out;
+}
+function customizationDiscoveryName(type) {
+    switch (type) {
+    case CustomizationType.Skill:
+        return localize(7564, "Skill Discovery");
+    case CustomizationType.Hook:
+        return localize(7565, "Hook Discovery");
+    case CustomizationType.Agent:
+        return localize(7566, "Agent Discovery");
+    case CustomizationType.McpServer:
+        return localize(7567, "MCP Server Discovery");
+    case CustomizationType.Rule:
+        return localize(7568, "Instructions Discovery");
+    case CustomizationType.Prompt:
+        return localize(7569, "Prompt Discovery");
+    default:
+        return localize(7570, "Customization Discovery");
+    }
+}
+function customizationSummaryCategory(c) {
+    if (!c.enabled) {
+        return "skipped";
+    }
+    switch (c.type) {
+    case CustomizationType.Skill:
+        return "skill";
+    case CustomizationType.Agent:
+        return "custom-agent";
+    case CustomizationType.Hook:
+        return "hook";
+    case CustomizationType.Rule:
+        return "applying";
+    default:
+        return undefined;
+    }
+}
+function buildCustomizationDebugEvents(customizations, sessionResource, parentEventId, created) {
+    const events = [];
+    const resolved = ( new Map());
+    const flat = flattenCustomizations(customizations);
+    if (flat.length === 0) {
+        return {
+            events,
+            resolved
+        };
+    }
+    const byType = ( new Map());
+    for (const c of flat) {
+        const list = byType.get(c.type);
+        if (list) {
+            list.push(c);
+        } else {
+            byType.set(c.type, [c]);
+        }
+    }
+    const key = ( sessionResource.toString());
+    for (const type of CUSTOMIZATION_TYPE_ORDER) {
+        const list = byType.get(type);
+        if (!list || list.length === 0) {
+            continue;
+        }
+        const id = `agentHostCustomization:${key}:${type}`;
+        const loadedCount = list.filter(c => c.enabled).length;
+        const skippedCount = list.length - loadedCount;
+        events.push({
+            kind: "generic",
+            id,
+            sessionResource,
+            created,
+            parentEventId,
+            name: customizationDiscoveryName(type),
+            details: skippedCount > 0 ? ( localize(7571, "{0} loaded, {1} disabled", loadedCount, skippedCount)) : ( localize(7572, "{0} loaded", loadedCount)),
+            level: ChatDebugLogLevel.Info,
+            category: "discovery"
+        });
+        const files = ( list.map(c => ({
+            uri: ( URI.parse(c.uri)),
+            name: c.name,
+            status: c.enabled ? "loaded" : "skipped",
+            skipReason: c.enabled ? undefined : ( localize(7573, "disabled"))
+        })));
+        resolved.set(id, {
+            kind: "fileList",
+            discoveryType: type,
+            durationInMillis: 0,
+            files
+        });
+    }
+    const logs = [];
+    for (const c of flat) {
+        const category = customizationSummaryCategory(c);
+        if (!category) {
+            continue;
+        }
+        logs.push({
+            category,
+            name: c.name,
+            uri: ( URI.parse(c.uri)),
+            reason: c.description
+        });
+    }
+    if (logs.length > 0) {
+        const id = `agentHostCustomization:${key}:summary`;
+        const counts = {
+            instructions: logs.filter(e => e.category === "applying" || e.category === "referenced").length,
+            skills: logs.filter(e => e.category === "skill").length,
+            agents: logs.filter(e => e.category === "custom-agent").length,
+            hooks: logs.filter(e => e.category === "hook").length,
+            skipped: logs.filter(e => e.category === "skipped").length
+        };
+        events.push({
+            kind: "generic",
+            id,
+            sessionResource,
+            created,
+            parentEventId,
+            name: ( localize(7574, "Resolve Customizations")),
+            details: ( localize(
+                7575,
+                "{0} skills, {1} agents, {2} hooks, {3} instructions",
+                counts.skills,
+                counts.agents,
+                counts.hooks,
+                counts.instructions
+            )),
+            level: ChatDebugLogLevel.Info,
+            category: "customization"
+        });
+        resolved.set(id, {
+            kind: "customizationSummary",
+            resolutionLogs: logs,
+            durationInMillis: 0,
+            counts
+        });
     }
     return {
         events,
         resolved
     };
 }
+function applyPerTurnUsage(events, resolved, modelTurnRefs, usageRecords) {
+    const assign = (ref, inputTokens, cachedTokens, copilotUsageNanoAiu) => {
+        const turn = events[ref.index];
+        const totalTokens = inputTokens !== undefined ? inputTokens + (ref.outputTokens ?? 0) : undefined;
+        events[ref.index] = {
+            ...turn,
+            inputTokens,
+            cachedTokens,
+            totalTokens,
+            copilotUsageNanoAiu
+        };
+        const detail = resolved.get(ref.id);
+        if (detail?.kind === "modelTurn") {
+            resolved.set(ref.id, {
+                ...detail,
+                inputTokens,
+                cachedTokens,
+                totalTokens
+            });
+        }
+    };
+    const aiuByRecordIndex = ( new Array(usageRecords.length)).fill(undefined);
+    for (let start = 0; start < usageRecords.length; ) {
+        let end = start;
+        while (end + 1 < usageRecords.length && usageRecords[end + 1].turnId === usageRecords[start].turnId) {
+            end++;
+        }
+        let maxAiu = 0;
+        for (let i = start; i <= end; i++) {
+            maxAiu = Math.max(maxAiu, usageRecords[i].totalNanoAiu ?? 0);
+        }
+        if (maxAiu > 0) {
+            aiuByRecordIndex[end] = maxAiu;
+        }
+        start = end + 1;
+    }
+    let recordIndex = 0;
+    let assignedInput = 0;
+    let assignedCache = 0;
+    let assignedAiu = 0;
+    const covered = ( new Set());
+    for (let refIdx = 0; refIdx < modelTurnRefs.length; refIdx++) {
+        if (recordIndex >= usageRecords.length) {
+            break;
+        }
+        const ref = modelTurnRefs[refIdx];
+        const record = usageRecords[recordIndex];
+        if (ref.outputTokens !== undefined && record.outputTokens !== undefined && ref.outputTokens !== record.outputTokens) {
+            continue;
+        }
+        const aiu = aiuByRecordIndex[recordIndex];
+        assign(ref, record.inputTokens, record.cacheReadTokens, aiu);
+        assignedInput += record.inputTokens ?? 0;
+        assignedCache += record.cacheReadTokens ?? 0;
+        assignedAiu += aiu ?? 0;
+        covered.add(refIdx);
+        recordIndex++;
+    }
+    return {
+        covered,
+        assignedInput,
+        assignedCache,
+        assignedAiu
+    };
+}
 function extractSessionUsageTotals(records) {
     let shutdown;
     for (const record of records) {
@@ -482,19 +1247,14 @@ function sumChatStateUsage(chat) {
     } : undefined;
 }
 function readCopilotNanoAiu(usage) {
-    const meta = usage._meta;
-    if (!meta || typeof meta !== "object") {
-        return 0;
-    }
-    const copilotUsage = meta.copilotUsage;
-    if (!copilotUsage || typeof copilotUsage !== "object") {
-        return 0;
-    }
-    const nano = copilotUsage.totalNanoAiu;
-    return typeof nano === "number" ? nano : 0;
+    return readUsageInfoMeta(usage).copilotUsage?.totalNanoAiu ?? 0;
 }
 function parseJsonl(text) {
     const records = [];
+    appendJsonlRecords(text, records);
+    return records;
+}
+function appendJsonlRecords(text, records) {
     for (const line of text.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) {
@@ -507,10 +1267,18 @@ function parseJsonl(text) {
             }
         } catch {}
     }
-    return records;
+}
+function lastIndexOfNewline(buffer) {
+    const bytes = buffer.buffer;
+    for (let i = bytes.length - 1; i >= 0; i--) {
+        if (bytes[i] === 0x0A ) {
+            return i;
+        }
+    }
+    return -1;
 }
 function fallbackSessionTitle(sessionId) {
-    return localize(6523, "Copilot CLI Session {0}", sessionId.slice(0, 8));
+    return localize(7576, "Copilot Session {0}", sessionId.slice(0, 8));
 }
 function extractSessionTitle(text) {
     for (const record of parseJsonl(text)) {
@@ -532,6 +1300,9 @@ function asNumber(value) {
 function asBoolean(value) {
     return typeof value === "boolean" ? value : undefined;
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
 function diffMillis(start, end) {
     const a = ( new Date(start)).getTime();
     const b = ( new Date(end)).getTime();
@@ -564,4 +1335,4 @@ function toErrorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
 
-export { AgentHostChatDebugContribution, convertAgentHostEventsToDebugEvents, parseJsonl };
+export { AgentHostChatDebugContribution, buildCustomizationDebugEvents, convertAgentHostEventsToDebugEvents, parseJsonl };