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

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetryReporter.d.ts

@@ -3,7 +3,7 @@ import { IObservableWithChange, IObservable } from "@codingame/monaco-vscode-api
 import { BaseStringEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit";
 import { StringText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-import type { ScmRepoAdapter } from "./scmAdapter.js";
+import type { IScmRepoAdapter } from "./scmAdapter.js";
 export declare class ArcTelemetryReporter extends Disposable {
     private readonly _timesMs;
     private readonly _documentValueBeforeTrackedEdit;
@@ -20,7 +20,7 @@ export declare class ArcTelemetryReporter extends Disposable {
         value: IObservableWithChange<StringText, {
             edit: BaseStringEdit;
         }>;
-    }, _gitRepo: IObservable<ScmRepoAdapter | undefined>, _trackedEdit: BaseStringEdit, _sendTelemetryEvent: (res: ArcTelemetryReporterData) => void, _dispose: () => void, _telemetryService: ITelemetryService);
+    }, _gitRepo: IObservable<IScmRepoAdapter | undefined>, _trackedEdit: BaseStringEdit, _sendTelemetryEvent: (res: ArcTelemetryReporterData) => void, _dispose: () => void, _telemetryService: ITelemetryService);
     private _reportAfter;
     private _report;
 }

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetrySender.d.ts

@@ -3,11 +3,11 @@ import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { EditSourceData, IDocumentWithAnnotatedEdits } from "../helpers/documentWithAnnotatedEdits.js";
 import { IAiEditTelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryService.service";
-import type { ScmRepoAdapter } from "./scmAdapter.js";
+import type { IScmRepoAdapter } from "./scmAdapter.js";
 import { IRandomService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service";
 export declare class EditTelemetryReportInlineEditArcSender extends Disposable {
     private readonly _instantiationService;
-    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<ScmRepoAdapter | undefined>, _instantiationService: IInstantiationService);
+    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<IScmRepoAdapter | undefined>, _instantiationService: IInstantiationService);
 }
 export declare class CreateSuggestionIdForChatOrInlineChatCaller extends Disposable {
     private readonly _aiEditTelemetryService;
@@ -16,5 +16,5 @@ export declare class CreateSuggestionIdForChatOrInlineChatCaller extends Disposa
 export declare class EditTelemetryReportEditArcForChatOrInlineChatSender extends Disposable {
     private readonly _instantiationService;
     private readonly _randomService;
-    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<ScmRepoAdapter | undefined>, _instantiationService: IInstantiationService, _randomService: IRandomService);
+    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<IScmRepoAdapter | undefined>, _instantiationService: IInstantiationService, _randomService: IRandomService);
 }

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetrySender.js

@@ -151,6 +151,9 @@ let EditTelemetryReportEditArcForChatOrInlineChatSender = class EditTelemetryRep
                         languageId: data.props.$$languageId,
                         mode: data.props.$$mode,
                         uniqueEditId,
+                        provider: undefined,
+                        agentSessionId: undefined,
+                        isSubagentSession: undefined,
                         didBranchChange: res.didBranchChange ? 1 : 0,
                         timeDelayMs: res.timeDelayMs,
                         originalCharCount: res.originalCharCount,

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingFeature.js

@@ -20,6 +20,7 @@ import { EditSourceTrackingImpl } from './editSourceTrackingImpl.js';
 import { DataChannelForwardingTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/browser/forwardingTelemetryService';
 import { EDIT_TELEMETRY_SHOW_DECORATIONS, EDIT_TELEMETRY_SHOW_STATUS_BAR, EDIT_TELEMETRY_DETAILS_SETTING_ID } from '../settings.js';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { AgentHostEditMarkerService } from './agentHostEditMarkerService.js';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { derived, derivedWithSetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
@@ -54,8 +55,8 @@ let EditTrackingFeature = class EditTrackingFeature extends Disposable {
         const extensions = observableFromEvent(this._extensionService.onDidChangeExtensions, () => {
             return this._extensionService.extensions;
         });
-        const extensionIds = derived(reader => ( new Set(( extensions.read(reader).map(e => e.id?.toLowerCase())))));
-        function getExtensionInfoObs(extensionId, extensionService) {
+        const extensionIds = derived(reader => ( new Set(( extensions.read(reader).map(e => e.identifier.value.toLowerCase())))));
+        function getExtensionInfoObs(extensionId) {
             const extIdLowerCase = extensionId.toLowerCase();
             return derived(reader => ( extensionIds.read(reader).has(extIdLowerCase)));
         }
@@ -68,9 +69,15 @@ let EditTrackingFeature = class EditTrackingFeature extends Disposable {
             ITelemetryService,
             this._instantiationService.createInstance(DataChannelForwardingTelemetryService)
         ])));
-        const impl = this._register(
-            instantiationServiceWithInterceptedTelemetry.createInstance(EditSourceTrackingImpl, shouldSendDetails, this._annotatedDocuments)
+        const markerService = this._register(
+            instantiationServiceWithInterceptedTelemetry.createInstance(AgentHostEditMarkerService)
         );
+        const impl = this._register(instantiationServiceWithInterceptedTelemetry.createInstance(
+            EditSourceTrackingImpl,
+            shouldSendDetails,
+            this._annotatedDocuments,
+            markerService
+        ));
         this._register(autorun(reader => {
             if (!this._editSourceTrackingShowDecorations.read(reader)) {
                 return;

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingImpl.d.ts

@@ -1,41 +1,52 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { EditTelemetryMode, EditTelemetryTrigger } from "../../../../../platform/telemetry/common/editTelemetry.js";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IUserAttentionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userAttention/common/userAttentionService.service";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { AnnotatedDocument, IAnnotatedDocuments } from "../helpers/annotatedDocuments.js";
+import { EditSource } from "../helpers/documentWithAnnotatedEdits.js";
 import { DocumentEditSourceTracker, TrackedEdit } from "./editTracker.js";
 import { ScmAdapter } from "./scmAdapter.js";
 import { IRandomService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service";
-type EditTelemetryMode = "longterm" | "10minFocusWindow" | "20minFocusWindow";
-type EditTelemetryTrigger = "10hours" | "hashChange" | "branchChange" | "closed" | "time";
+import { IAgentHostEditMarkerService } from "./agentHostEditMarkerService.js";
+export type EditTelemetryCategory = "nes" | "inlineCompletionsCopilot" | "inlineCompletionsNES" | "inlineCompletionsOther" | "otherAI" | "agentHost" | "user" | "ide" | "external" | "unknown";
+export declare function getEditTelemetryCategory(source: EditSource): EditTelemetryCategory;
 export declare class EditSourceTrackingImpl extends Disposable {
     private readonly _statsEnabled;
     private readonly _annotatedDocuments;
+    private readonly _agentHostEditMarkerService;
     private readonly _instantiationService;
     readonly docsState: IObservable<Map<import("../helpers/observableWorkspace.js").IObservableDocument, TrackedDocumentInfo>>;
     private readonly _states;
-    constructor(_statsEnabled: IObservable<boolean>, _annotatedDocuments: IAnnotatedDocuments, _instantiationService: IInstantiationService);
+    constructor(_statsEnabled: IObservable<boolean>, _annotatedDocuments: IAnnotatedDocuments, _agentHostEditMarkerService: IAgentHostEditMarkerService | undefined, _instantiationService: IInstantiationService);
 }
 declare class TrackedDocumentInfo extends Disposable {
     private readonly _doc;
     private readonly _scm;
     private readonly _statsEnabled;
+    private readonly _agentHostEditMarkerService;
     private readonly _instantiationService;
     private readonly _telemetryService;
     private readonly _randomService;
     private readonly _userAttentionService;
+    private readonly _textFileService;
+    private readonly _logService;
     readonly longtermTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
     readonly windowedTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
     readonly windowedFocusTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
     private readonly _repo;
-    constructor(_doc: AnnotatedDocument, _scm: ScmAdapter, _statsEnabled: IObservable<boolean>, _instantiationService: IInstantiationService, _telemetryService: ITelemetryService, _randomService: IRandomService, _userAttentionService: IUserAttentionService);
+    constructor(_doc: AnnotatedDocument, _scm: ScmAdapter, _statsEnabled: IObservable<boolean>, _agentHostEditMarkerService: IAgentHostEditMarkerService | undefined, _instantiationService: IInstantiationService, _telemetryService: ITelemetryService, _randomService: IRandomService, _userAttentionService: IUserAttentionService, _textFileService: ITextFileService, _logService: ILogService);
+    private _sendTelemetryAndLog;
     sendTelemetry(mode: EditTelemetryMode, trigger: EditTelemetryTrigger, t: DocumentEditSourceTracker, focusTime: number, actualTime: number): Promise<void>;
     getTelemetryData(ranges: readonly TrackedEdit[]): {
         nesModifiedCount: number;
         inlineCompletionsCopilotModifiedCount: number;
         inlineCompletionsNESModifiedCount: number;
         otherAIModifiedCount: number;
+        agentHostModifiedCount: number;
         userModifiedCount: number;
         ideModifiedCount: number;
         unknownModifiedCount: number;

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingImpl.js

@@ -5,57 +5,112 @@ import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/commo
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { sendEditSourcesDetailsTelemetry, sendEditSourcesStatsTelemetry } from '../../../../../platform/telemetry/common/editTelemetry.js';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IUserAttentionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userAttention/common/userAttentionService.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { EditTelemetryReportInlineEditArcSender, EditTelemetryReportEditArcForChatOrInlineChatSender, CreateSuggestionIdForChatOrInlineChatCaller } from './arcTelemetrySender.js';
 import { createDocWithJustReason } from '../helpers/documentWithAnnotatedEdits.js';
 import { DocumentEditSourceTracker } from './editTracker.js';
 import { sumByCategory } from '../helpers/utils.js';
 import { ScmAdapter } from './scmAdapter.js';
 import { IRandomService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service';
+import { AgentHostEditAttributionDeferredError, AgentHostEditAttributionUnknownOutcomeError } from './agentHostEditMarkerService.js';
 import { mapObservableArrayCached } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
 
+const FOCUS_CORRELATION_DRAIN_TIMEOUT = 1_000;
+function getEditTelemetryCategory(source) {
+    if (source.category === "ai" && source.kind === "nes") {
+        return "nes";
+    }
+    if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot") {
+        return "inlineCompletionsCopilot";
+    }
+    if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "nes") {
+        return "inlineCompletionsNES";
+    }
+    if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "completions") {
+        return "inlineCompletionsCopilot";
+    }
+    if (source.category === "ai" && source.kind === "completion") {
+        return "inlineCompletionsOther";
+    }
+    if (source.category === "ai") {
+        return "otherAI";
+    }
+    if (source.category === "agentHost") {
+        return "agentHost";
+    }
+    if (source.category === "user") {
+        return "user";
+    }
+    if (source.category === "ide") {
+        return "ide";
+    }
+    if (source.category === "external") {
+        return "external";
+    }
+    return "unknown";
+}
 let EditSourceTrackingImpl = class EditSourceTrackingImpl extends Disposable {
-    constructor(_statsEnabled, _annotatedDocuments, _instantiationService) {
+    constructor(
+        _statsEnabled,
+        _annotatedDocuments,
+        _agentHostEditMarkerService,
+        _instantiationService
+    ) {
         super();
         this._statsEnabled = _statsEnabled;
         this._annotatedDocuments = _annotatedDocuments;
+        this._agentHostEditMarkerService = _agentHostEditMarkerService;
         this._instantiationService = _instantiationService;
         const scmBridge = this._instantiationService.createInstance(ScmAdapter);
         this._states = mapObservableArrayCached(this, this._annotatedDocuments.documents, (doc, store) => {
-            return [doc.document, store.add(
-                this._instantiationService.createInstance(TrackedDocumentInfo, doc, scmBridge, this._statsEnabled)
-            )];
+            return [doc.document, store.add(this._instantiationService.createInstance(
+                TrackedDocumentInfo,
+                doc,
+                scmBridge,
+                this._statsEnabled,
+                this._agentHostEditMarkerService
+            ))];
         });
         this.docsState = ( this._states.map(entries => ( new Map(entries))));
         this.docsState.recomputeInitiallyAndOnChange(this._store);
     }
 };
-EditSourceTrackingImpl = ( __decorate([( __param(2, IInstantiationService))], EditSourceTrackingImpl));
+EditSourceTrackingImpl = ( __decorate([( __param(3, IInstantiationService))], EditSourceTrackingImpl));
 let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
     constructor(
         _doc,
         _scm,
         _statsEnabled,
+        _agentHostEditMarkerService,
         _instantiationService,
         _telemetryService,
         _randomService,
-        _userAttentionService
+        _userAttentionService,
+        _textFileService,
+        _logService
     ) {
         super();
         this._doc = _doc;
         this._scm = _scm;
         this._statsEnabled = _statsEnabled;
+        this._agentHostEditMarkerService = _agentHostEditMarkerService;
         this._instantiationService = _instantiationService;
         this._telemetryService = _telemetryService;
         this._randomService = _randomService;
         this._userAttentionService = _userAttentionService;
+        this._textFileService = _textFileService;
+        this._logService = _logService;
         this._repo = derived(this, reader => this._scm.getRepo(_doc.document.uri, reader));
         const docWithJustReason = createDocWithJustReason(_doc.documentWithAnnotations, this._store);
+        const externalEditCorrelation = this._agentHostEditMarkerService?.createCorrelation(_doc.document.uri);
         const longtermResetSignal = observableSignal("resetSignal");
         let longtermReason = "closed";
         this.longtermTracker = derived(reader => {
@@ -63,20 +118,18 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
                 return undefined;
             }
             longtermResetSignal.read(reader);
-            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const t = ( new DocumentEditSourceTracker(docWithJustReason, undefined, externalEditCorrelation));
             const startFocusTime = this._userAttentionService.totalFocusTimeMs;
             const startTime = Date.now();
             reader.store.add(toDisposable(() => {
-                if (!t.isEmpty()) {
-                    this.sendTelemetry(
-                        "longterm",
-                        longtermReason,
-                        t,
-                        this._userAttentionService.totalFocusTimeMs - startFocusTime,
-                        Date.now() - startTime
-                    );
-                }
-                t.dispose();
+                t.stopTracking();
+                this._sendTelemetryAndLog(
+                    "longterm",
+                    longtermReason,
+                    t,
+                    this._userAttentionService.totalFocusTimeMs - startFocusTime,
+                    Date.now() - startTime
+                );
             }));
             return t;
         }).recomputeInitiallyAndOnChange(this._store);
@@ -127,18 +180,18 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
                     resetSignal.trigger(undefined);
                 })
             );
-            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const t = ( new DocumentEditSourceTracker(docWithJustReason, undefined, externalEditCorrelation, "reattribute"));
             const startFocusTime = this._userAttentionService.totalFocusTimeMs;
             const startTime = Date.now();
-            reader.store.add(toDisposable(async () => {
-                this.sendTelemetry(
+            reader.store.add(toDisposable(() => {
+                t.stopTracking();
+                this._sendTelemetryAndLog(
                     "10minFocusWindow",
                     "time",
                     t,
                     this._userAttentionService.totalFocusTimeMs - startFocusTime,
                     Date.now() - startTime
                 );
-                t.dispose();
             }));
             return t;
         }).recomputeInitiallyAndOnChange(this._store);
@@ -156,46 +209,118 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
                     focusResetSignal.trigger(undefined);
                 })
             );
-            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const t = ( new DocumentEditSourceTracker(docWithJustReason, undefined, externalEditCorrelation, "reattribute"));
             const startFocusTime = this._userAttentionService.totalFocusTimeMs;
             const startTime = Date.now();
-            reader.store.add(toDisposable(async () => {
-                this.sendTelemetry(
+            reader.store.add(toDisposable(() => {
+                t.stopTracking();
+                this._sendTelemetryAndLog(
                     "20minFocusWindow",
                     "time",
                     t,
                     this._userAttentionService.totalFocusTimeMs - startFocusTime,
                     Date.now() - startTime
                 );
-                t.dispose();
             }));
             return t;
         }).recomputeInitiallyAndOnChange(this._store);
     }
+    _sendTelemetryAndLog(mode, trigger, tracker, focusTime, actualTime) {
+        void this.sendTelemetry(mode, trigger, tracker, focusTime, actualTime).catch(error => {
+            this._logService.error(`[EditSourceTrackingImpl] Failed to send ${mode} edit telemetry: ${error}`);
+        }).finally(() => {
+            tracker.releaseExternalEditCorrelations();
+            tracker.dispose();
+        });
+    }
     async sendTelemetry(mode, trigger, t, focusTime, actualTime) {
-        const ranges = t.getTrackedRanges();
-        const keys = t.getAllKeys();
-        if (keys.length === 0) {
-            return;
+        if (mode !== "longterm") {
+            await t.waitForExternalEditCorrelations(FOCUS_CORRELATION_DRAIN_TIMEOUT);
         }
-        const data = this.getTelemetryData(ranges);
+        t.applyPendingExternalEdits();
+        let ranges = t.getTrackedRanges();
+        let internalKeys = t.getAllKeys();
+        let data = this.getTelemetryData(ranges);
         const statsUuid = this._randomService.generateUuid();
-        const sums = sumByCategory(ranges, r => r.range.length, r => r.sourceKey);
-        const entries = Object.entries(sums).filter(([key, value]) => value !== undefined);
-        entries.sort(reverseOrder(compareBy(([key, value]) => value, numberComparator)));
-        entries.length = mode === "longterm" ? 30 : 10;
-        for (const key of keys) {
-            if (!sums[key]) {
-                sums[key] = 0;
+        let preparedAgentFlush;
+        let deferSuppressedExternal = false;
+        const isDirty = this._textFileService.isDirty(this._doc.document.uri);
+        if (mode === "longterm" && this._agentHostEditMarkerService) {
+            try {
+                preparedAgentFlush = await this._agentHostEditMarkerService.prepareFlush(
+                    this._doc.document.uri,
+                    trigger,
+                    statsUuid,
+                    isDirty,
+                    this._doc.document.languageId.get()
+                );
+            } catch (error) {
+                this._logService.error(
+                    `[EditSourceTrackingImpl] Failed to prepare Agent Host edit attribution: ${error}`
+                );
+                deferSuppressedExternal = error instanceof AgentHostEditAttributionDeferredError || error instanceof AgentHostEditAttributionUnknownOutcomeError;
+            }
+        }
+        if (preparedAgentFlush) {
+            t.applyPendingExternalEdits();
+            ranges = t.getTrackedRanges();
+            internalKeys = t.getAllKeys();
+            data = this.getTelemetryData(ranges);
+            try {
+                await preparedAgentFlush.commit(
+                    data.totalModifiedCharactersInFinalState + preparedAgentFlush.agentModifiedCount
+                );
+            } catch (error) {
+                this._logService.error(
+                    `[EditSourceTrackingImpl] Failed to commit Agent Host edit attribution: ${error}`
+                );
+                if (!(error instanceof AgentHostEditAttributionUnknownOutcomeError)) {
+                    preparedAgentFlush = undefined;
+                }
+                deferSuppressedExternal = error instanceof AgentHostEditAttributionDeferredError || error instanceof AgentHostEditAttributionUnknownOutcomeError;
             }
         }
-        for (const [key, value] of Object.entries(sums)) {
-            if (value === undefined) {
-                continue;
+        const includeSuppressedExternal = !preparedAgentFlush && !deferSuppressedExternal && !isDirty && mode === "longterm" && !!this._agentHostEditMarkerService;
+        if (includeSuppressedExternal) {
+            ranges = t.getTrackedRanges(undefined, true);
+            internalKeys = t.getAllKeys(true);
+            data = this.getTelemetryData(ranges);
+        }
+        const coverageGap = mode === "longterm" && !isDirty && !deferSuppressedExternal && !preparedAgentFlush?.deferCoverageGap ? this._agentHostEditMarkerService?.takeCoverageGap?.(
+            this._doc.document.uri,
+            preparedAgentFlush?.coverageGapThroughSequence ?? preparedAgentFlush?.lastSequence
+        ) : undefined;
+        const agentModifiedCount = mode === "longterm" ? preparedAgentFlush?.agentModifiedCount ?? 0 : data.agentHostModifiedCount;
+        if (internalKeys.length === 0 && agentModifiedCount === 0 && !coverageGap) {
+            return;
+        }
+        const totalModifiedCount = data.totalModifiedCharactersInFinalState + (preparedAgentFlush?.agentModifiedCount ?? 0);
+        const telemetryKeys = ( new Map());
+        for (const internalKey of internalKeys) {
+            const representative = t.getRepresentative(internalKey);
+            const telemetryKey = representative.toKey(1);
+            const entry = telemetryKeys.get(telemetryKey) ?? {
+                representative,
+                modifiedCount: 0,
+                deltaModifiedCount: 0
+            };
+            entry.deltaModifiedCount += t.getTotalInsertedCharactersCount(internalKey, includeSuppressedExternal);
+            telemetryKeys.set(telemetryKey, entry);
+        }
+        for (const range of ranges) {
+            const representative = t.getRepresentative(range.sourceKey);
+            const entry = telemetryKeys.get(representative.toKey(1));
+            if (entry) {
+                entry.modifiedCount += range.range.length;
             }
-            const repr = t.getRepresentative(key);
-            const deltaModifiedCount = t.getTotalInsertedCharactersCount(key);
-            this._telemetryService.publicLog2("editTelemetry.editSources.details", {
+        }
+        const sums = Object.fromEntries(Array.from(telemetryKeys, ([key, value]) => [key, value.modifiedCount]));
+        const entries = Object.entries(sums).filter(entry => entry[1] !== undefined).sort(reverseOrder(compareBy(([, value]) => value, numberComparator))).slice(0, mode === "longterm" ? 30 : 10);
+        for (const [key, value] of entries) {
+            const telemetryEntry = telemetryKeys.get(key);
+            const repr = telemetryEntry.representative;
+            const deltaModifiedCount = telemetryEntry.deltaModifiedCount;
+            sendEditSourcesDetailsTelemetry(this._telemetryService, {
                 mode,
                 sourceKey: key,
                 sourceKeyCleaned: repr.toKey(1, {
@@ -211,13 +336,16 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
                 statsUuid: statsUuid,
                 conversationId: repr.props.$$sessionId,
                 requestId: repr.props.$$requestId,
+                origin: repr.props.$origin,
+                harness: repr.props.$harness,
                 modifiedCount: value,
                 deltaModifiedCount: deltaModifiedCount,
-                totalModifiedCount: data.totalModifiedCharactersInFinalState
+                totalModifiedCount
             });
         }
         const isTrackedByGit = await data.isTrackedByGit;
-        this._telemetryService.publicLog2("editTelemetry.editSources.stats", {
+        sendEditSourcesStatsTelemetry(this._telemetryService, {
+            attributionSchemaVersion: 2,
             mode,
             languageId: this._doc.document.languageId.get(),
             statsUuid: statsUuid,
@@ -225,58 +353,32 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
             inlineCompletionsCopilotModifiedCount: data.inlineCompletionsCopilotModifiedCount,
             inlineCompletionsNESModifiedCount: data.inlineCompletionsNESModifiedCount,
             otherAIModifiedCount: data.otherAIModifiedCount,
+            agentHostModifiedCount: agentModifiedCount,
             unknownModifiedCount: data.unknownModifiedCount,
             userModifiedCount: data.userModifiedCount,
             ideModifiedCount: data.ideModifiedCount,
-            totalModifiedCharacters: data.totalModifiedCharactersInFinalState,
+            totalModifiedCharacters: totalModifiedCount,
             externalModifiedCount: data.externalModifiedCount,
             isTrackedByGit: isTrackedByGit ? 1 : 0,
             focusTime,
             actualTime,
-            trigger
+            trigger,
+            ...(mode === "longterm" ? {
+                agentHostAttributionCoverage: coverageGap ? "partial" : "complete",
+                agentHostUntrackedEditCount: coverageGap?.editCount ?? 0,
+                agentHostUntrackedInsertedCount: coverageGap?.insertedCount ?? 0
+            } : {})
         });
     }
     getTelemetryData(ranges) {
-        const getEditCategory = source => {
-            if (source.category === "ai" && source.kind === "nes") {
-                return "nes";
-            }
-            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot") {
-                return "inlineCompletionsCopilot";
-            }
-            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "completions") {
-                return "inlineCompletionsCopilot";
-            }
-            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "nes") {
-                return "inlineCompletionsNES";
-            }
-            if (source.category === "ai" && source.kind === "completion") {
-                return "inlineCompletionsOther";
-            }
-            if (source.category === "ai") {
-                return "otherAI";
-            }
-            if (source.category === "user") {
-                return "user";
-            }
-            if (source.category === "ide") {
-                return "ide";
-            }
-            if (source.category === "external") {
-                return "external";
-            }
-            if (source.category === "unknown") {
-                return "unknown";
-            }
-            return "unknown";
-        };
-        const sums = sumByCategory(ranges, r => r.range.length, r => getEditCategory(r.source));
+        const sums = sumByCategory(ranges, r => r.range.length, r => getEditTelemetryCategory(r.source));
         const totalModifiedCharactersInFinalState = sumBy(ranges, r => r.range.length);
         return {
             nesModifiedCount: sums.nes ?? 0,
             inlineCompletionsCopilotModifiedCount: sums.inlineCompletionsCopilot ?? 0,
             inlineCompletionsNESModifiedCount: sums.inlineCompletionsNES ?? 0,
             otherAIModifiedCount: sums.otherAI ?? 0,
+            agentHostModifiedCount: sums.agentHost ?? 0,
             userModifiedCount: sums.user ?? 0,
             ideModifiedCount: sums.ide ?? 0,
             unknownModifiedCount: sums.unknown ?? 0,
@@ -287,6 +389,6 @@ let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
         };
     }
 };
-TrackedDocumentInfo = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, ITelemetryService)), ( __param(5, IRandomService)), ( __param(6, IUserAttentionService))], TrackedDocumentInfo));
+TrackedDocumentInfo = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, ITelemetryService)), ( __param(6, IRandomService)), ( __param(7, IUserAttentionService)), ( __param(8, ITextFileService)), ( __param(9, ILogService))], TrackedDocumentInfo));
 
-export { EditSourceTrackingImpl };
+export { EditSourceTrackingImpl, getEditTelemetryCategory };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editTracker.d.ts

@@ -3,32 +3,48 @@ import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 import { OffsetRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange";
 import { TextModelEditSource } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource";
 import { IDocumentWithAnnotatedEdits, EditSource } from "../helpers/documentWithAnnotatedEdits.js";
+import { IExternalEditCorrelation } from "./agentHostEditMarkerService.js";
+export type ExternalEditCorrelationPolicy = "suppress" | "reattribute";
 /**
  * Tracks a single document.
 */
 export declare class DocumentEditSourceTracker<T = void> extends Disposable {
     private readonly _doc;
     readonly data: T;
+    private readonly _externalEditCorrelation?;
+    private readonly _externalEditCorrelationPolicy;
     private _edits;
     private _pendingExternalEdits;
     private readonly _update;
+    private readonly _documentStore;
     private readonly _representativePerKey;
     private readonly _sumAddedCharactersPerKey;
-    constructor(_doc: IDocumentWithAnnotatedEdits, data: T);
+    private readonly _externalObservationIds;
+    private readonly _ignoredInitialExternalObservationIds;
+    private readonly _suppressedExternalObservationIds;
+    private readonly _invalidatedExternalObservationIds;
+    private readonly _reattributedExternalObservations;
+    constructor(_doc: IDocumentWithAnnotatedEdits, data: T, _externalEditCorrelation?: IExternalEditCorrelation | undefined, _externalEditCorrelationPolicy?: ExternalEditCorrelationPolicy);
+    releaseExternalEditCorrelations(): void;
+    stopTracking(): void;
+    waitForExternalEditCorrelations(timeoutMs: number): Promise<void>;
     private _applyEdit;
     waitForQueue(): Promise<void>;
-    getTotalInsertedCharactersCount(key: string): number;
-    getAllKeys(): string[];
+    getTotalInsertedCharactersCount(key: string, includeSuppressed?: boolean): number;
+    getAllKeys(includeSuppressed?: boolean): string[];
     getRepresentative(key: string): TextModelEditSource | undefined;
-    getTrackedRanges(reader?: IReader): TrackedEdit[];
+    applyPendingExternalEdits(): void;
+    getTrackedRanges(reader?: IReader, includeSuppressed?: boolean): TrackedEdit[];
     isEmpty(): boolean;
+    private _shouldIncludeKey;
+    private _resolveExternalObservation;
     _getDebugVisualization(): {
+        $fileExtension: string;
         value: string;
         decorations: {
             range: number[];
             color: string;
         }[];
-        $fileExtension: string;
     };
 }
 export declare class TrackedEdit {