@theia/ai-chat 1.75.0-next.21 → 1.75.0-next.28

package/lib/common/file-read-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-read-tracker.d.ts","sourceRoot":"","sources":["../../src/common/file-read-tracker.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAElC,eAAO,MAAM,eAAe,eAA4B,CAAC;AAEzD,wHAAwH;AACxH,MAAM,WAAW,eAAe;IAC5B,mIAAmI;IACnI,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzE,gJAAgJ;IAChJ,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,uIAAuI;IACvI,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACzD"}

package/lib/common/file-read-tracker.js

@@ -0,0 +1,20 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2026 Ehab Younes.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReadTracker = void 0;
+exports.FileReadTracker = Symbol('FileReadTracker');
+//# sourceMappingURL=file-read-tracker.js.map

package/lib/common/file-read-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-read-tracker.js","sourceRoot":"","sources":["../../src/common/file-read-tracker.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,kCAAkC;AAClC,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;AAInE,QAAA,eAAe,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC"}

package/lib/common/index.d.ts

@@ -12,6 +12,7 @@ export * from './custom-chat-agent';
 export * from './parsed-chat-request';
 export * from './context-variables';
 export * from './chat-tool-request-service';
+export * from './file-read-tracker';
 export * from './chat-tool-confirmation-timeout';
 export * from './provider-error-formatter';
 //# sourceMappingURL=index.d.ts.map

package/lib/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAeA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qCAAqC,CAAC;AACpD,cAAc,cAAc,CAAC;AAC7B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAeA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qCAAqC,CAAC;AACpD,cAAc,cAAc,CAAC;AAC7B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC"}

package/lib/common/index.js

@@ -30,6 +30,7 @@ tslib_1.__exportStar(require("./custom-chat-agent"), exports);
 tslib_1.__exportStar(require("./parsed-chat-request"), exports);
 tslib_1.__exportStar(require("./context-variables"), exports);
 tslib_1.__exportStar(require("./chat-tool-request-service"), exports);
+tslib_1.__exportStar(require("./file-read-tracker"), exports);
 tslib_1.__exportStar(require("./chat-tool-confirmation-timeout"), exports);
 tslib_1.__exportStar(require("./provider-error-formatter"), exports);
 //# sourceMappingURL=index.js.map

package/lib/common/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":";;;AAAA,gFAAgF;AAChF,yCAAyC;AACzC,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAChF,wDAA8B;AAC9B,+DAAqC;AACrC,8EAAoD;AACpD,uDAA6B;AAC7B,qEAA2C;AAC3C,sEAA4C;AAC5C,4DAAkC;AAClC,gEAAsC;AACtC,yDAA+B;AAC/B,+DAAqC;AACrC,8DAAoC;AACpC,gEAAsC;AACtC,8DAAoC;AACpC,sEAA4C;AAC5C,2EAAiD;AACjD,qEAA2C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":";;;AAAA,gFAAgF;AAChF,yCAAyC;AACzC,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAChF,wDAA8B;AAC9B,+DAAqC;AACrC,8EAAoD;AACpD,uDAA6B;AAC7B,qEAA2C;AAC3C,sEAA4C;AAC5C,4DAAkC;AAClC,gEAAsC;AACtC,yDAA+B;AAC/B,+DAAqC;AACrC,8DAAoC;AACpC,gEAAsC;AACtC,8DAAoC;AACpC,sEAA4C;AAC5C,8DAAoC;AACpC,2EAAiD;AACjD,qEAA2C"}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@theia/ai-chat",
-  "version": "1.75.0-next.21+fa058c354",
+  "version": "1.75.0-next.28+ba1005c0bf8",
   "description": "Theia - AI Chat Extension",
   "dependencies": {
-    "@theia/ai-core": "1.75.0-next.21+fa058c354",
-    "@theia/core": "1.75.0-next.21+fa058c354",
-    "@theia/editor": "1.75.0-next.21+fa058c354",
-    "@theia/file-search": "1.75.0-next.21+fa058c354",
-    "@theia/filesystem": "1.75.0-next.21+fa058c354",
-    "@theia/monaco": "1.75.0-next.21+fa058c354",
+    "@theia/ai-core": "1.75.0-next.28+ba1005c0bf8",
+    "@theia/core": "1.75.0-next.28+ba1005c0bf8",
+    "@theia/editor": "1.75.0-next.28+ba1005c0bf8",
+    "@theia/file-search": "1.75.0-next.28+ba1005c0bf8",
+    "@theia/filesystem": "1.75.0-next.28+ba1005c0bf8",
+    "@theia/monaco": "1.75.0-next.28+ba1005c0bf8",
     "@theia/monaco-editor-core": "1.108.201",
-    "@theia/workspace": "1.75.0-next.21+fa058c354",
+    "@theia/workspace": "1.75.0-next.28+ba1005c0bf8",
     "js-yaml": "^4.3.1",
     "tslib": "^2.8.1"
   },
@@ -54,5 +54,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "fa058c354e5bfa630cb6766d042131cc8de8a7ff"
+  "gitHead": "ba1005c0bf87bd848c6ec51ce1b4e6bb06748e3c"
 }

package/src/browser/ai-chat-frontend-module.ts

@@ -42,6 +42,8 @@ import { CustomAgentFactory } from './custom-agent-factory';
 import { ChatToolRequestService } from '../common/chat-tool-request-service';
 import { FrontendChatToolRequestService } from './chat-tool-request-service';
 import { ChangeSetFileService } from './change-set-file-service';
+import { FileReadTracker } from '../common/file-read-tracker';
+import { FileReadTrackerImpl } from './file-read-tracker-impl';
 import { ContextVariableLabelProvider } from './context-variable-label-provider';
 import { ContextFileVariableLabelProvider } from './context-file-variable-label-provider';
 import { FileChatVariableContribution } from './file-chat-variable-contribution';
@@ -168,6 +170,9 @@ export default new ContainerModule(bind => {
     bind(ContextFileVariableLabelProvider).toSelf().inSingletonScope();
     bind(LabelProviderContribution).toService(ContextFileVariableLabelProvider);
 
+    bind(FileReadTrackerImpl).toSelf().inSingletonScope();
+    bind(FileReadTracker).toService(FileReadTrackerImpl);
+
     bind(ChangeSetFileService).toSelf().inSingletonScope();
     bind(ChangeSetFileElementFactory).toFactory(ctx => (args: ChangeSetElementArgs) => {
         const container = ctx.container.createChild();

package/src/browser/change-set-file-element.ts

@@ -34,6 +34,7 @@ import { insertFinalNewline } from '@theia/monaco/lib/browser/monaco-utilities';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
 import { ChangeSetElement } from '../common';
+import { FileReadTracker } from '../common/file-read-tracker';
 import { SerializableChangeSetElement } from '../common/chat-model-serialization';
 import { createChangeSetFileUri } from './change-set-file-resource';
 import { ChangeSetFileService } from './change-set-file-service';
@@ -106,6 +107,9 @@ export class ChangeSetFileElement implements ChangeSetElement {
     @inject(MonacoWorkspace)
     protected readonly monacoWorkspace: MonacoWorkspace;
 
+    @inject(FileReadTracker)
+    protected readonly fileReadTracker: FileReadTracker;
+
     protected readonly toDispose = new DisposableCollection();
     protected _state: ChangeSetElementState;
 
@@ -303,13 +307,12 @@ export class ChangeSetFileElement implements ChangeSetElement {
         if (this.type === 'delete') {
             await this.changeSetFileService.delete(this.uri);
             this.state = 'applied';
-            this.changeSetFileService.closeDiff(this.readOnlyUri);
-            return;
+        } else {
+            await this.applyChangesWithMonaco(contents);
         }
-
-        // Load Monaco model for the base file URI and apply changes
-        await this.applyChangesWithMonaco(contents);
         this.changeSetFileService.closeDiff(this.readOnlyUri);
+        // Re-snapshot so the agent's own write is not reported back as external, reading because code actions and formatting on save alter the target state.
+        await this.fileReadTracker.recordRead(this.elementProps.chatSessionId, this.uri);
     }
 
     async writeChanges(contents?: string): Promise<void> {

package/src/browser/file-read-tracker-impl.spec.ts

@@ -0,0 +1,318 @@
+// *****************************************************************************
+// Copyright (C) 2026 Ehab Younes.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { Emitter, Event, URI } from '@theia/core';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { FileChangesEvent, FileChangeType, FileOperationError, FileOperationResult, FileStat } from '@theia/filesystem/lib/common/files';
+import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
+import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
+import { expect } from 'chai';
+import { FileReadTrackerImpl } from './file-read-tracker-impl';
+
+disableJSDOM();
+
+const SESSION = 'session-1';
+const OTHER_SESSION = 'session-2';
+const ROOT = new URI('file:///workspace');
+const FILE = ROOT.resolve('a.ts');
+/** As `resolveRelativePath` expects it back: root name plus path within that root. */
+const FILE_LABEL = 'workspace/a.ts';
+
+/** Drives the tracker against in-memory content: `contents` stands in for the files on disk. */
+class TestFileReadTracker extends FileReadTrackerImpl {
+    readonly contents = new Map<string, string>([[FILE.toString(), 'original']]);
+    /** Makes reading fail as a file too large to compare would, rather than as a missing one. */
+    readFails = false;
+    /** Runs once inside a read, to change the file while the tracker is still reading it. */
+    duringNextRead?: () => void;
+    /** The encoding the files are stored in: `read` decodes with it, `readFile` hands back their bytes. */
+    encoding: BufferEncoding = 'utf8';
+    protected override readonly maxFilesPerSession = 2;
+    /** The workspace roots labels are built against. */
+    readonly roots = [ROOT];
+    protected override readonly workspaceService = {
+        tryGetRoots: () => this.roots.map(resource => ({ resource } as FileStat))
+    } as WorkspaceService;
+    protected override readonly monacoWorkspace = { getTextDocument: () => undefined } as unknown as MonacoWorkspace;
+    /** Both decoders, so that a test can tell which one the tracker reads through. */
+    protected override readonly fileService = {
+        read: async (uri: URI) => ({ value: this.contentOf(uri) }),
+        readFile: async (uri: URI) => ({ value: BinaryBuffer.wrap(Buffer.from(this.contentOf(uri), this.encoding)) })
+    } as unknown as FileService;
+    protected readonly fileChangeEmitter = new Emitter<FileChangesEvent>();
+    protected readonly documentChangeEmitter = new Emitter<string>();
+
+    constructor() {
+        super();
+        // `@postConstruct` only runs on container resolution, so wire the listeners here.
+        this.init();
+    }
+
+    protected override get fileChanges(): Event<FileChangesEvent> {
+        return this.fileChangeEmitter.event;
+    }
+
+    protected override get documentChanges(): Event<string> {
+        return this.documentChangeEmitter.event;
+    }
+
+    /** Stands in for the file on disk, failing the way the file service would. */
+    protected contentOf(uri: URI): string {
+        if (this.readFails) {
+            throw new FileOperationError(`${uri} is too large`, FileOperationResult.FILE_TOO_LARGE);
+        }
+        const content = this.contents.get(uri.toString());
+        if (content === undefined) {
+            throw new FileOperationError(`${uri} does not exist`, FileOperationResult.FILE_NOT_FOUND);
+        }
+        const during = this.duringNextRead;
+        this.duringNextRead = undefined;
+        during?.();
+        return content;
+    }
+
+    /** Records what the agent saw, as `getFileContent` does. */
+    agentRead(uri = FILE, sessionId = SESSION): Promise<void> {
+        return this.recordRead(sessionId, uri, this.contents.get(uri.toString()));
+    }
+
+    /** Changes content behind the agent's back and notifies the tracker, as the workspace would. */
+    somebodyElseChanges(content: string, uri = FILE): void {
+        this.contents.set(uri.toString(), content);
+        this.fileChanged(uri);
+    }
+
+    somebodyElseDeletes(uri = FILE): void {
+        this.contents.delete(uri.toString());
+        this.fileChanged(uri);
+    }
+
+    fileChanged(...uris: URI[]): void {
+        this.fileChangeEmitter.fire(new FileChangesEvent(uris.map(resource => ({ resource, type: FileChangeType.UPDATED }))));
+    }
+
+    documentChanged(uri = FILE): void {
+        this.documentChangeEmitter.fire(uri.toString());
+    }
+}
+
+describe('FileReadTrackerImpl', () => {
+
+    it('reports a file that changed after it was read', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+
+        tracker.somebodyElseChanges('changed');
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+        expect(await tracker.isStale(SESSION, FILE)).to.be.true;
+    });
+
+    it('reports a file whose unsaved document changed', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+
+        tracker.contents.set(FILE.toString(), 'the user typed something');
+        tracker.documentChanged();
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+    });
+
+    it('keeps reporting a change until the file is read again', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+        tracker.somebodyElseChanges('changed');
+        expect(await tracker.getChangedFiles(SESSION)).to.have.lengthOf(1);
+        expect(await tracker.getChangedFiles(SESSION)).to.have.lengthOf(1);
+
+        await tracker.agentRead();
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+        expect(await tracker.isStale(SESSION, FILE)).to.be.false;
+    });
+
+    it('ignores files that were never read', async () => {
+        const tracker = new TestFileReadTracker();
+
+        tracker.somebodyElseChanges('changed');
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+        expect(await tracker.isStale(SESSION, FILE)).to.be.false;
+    });
+
+    it('ignores a change that left the content untouched', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+
+        // e.g. saving an unmodified document, or a formatter that had nothing to do
+        tracker.fileChanged(FILE);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+        expect(await tracker.isStale(SESSION, FILE)).to.be.false;
+    });
+
+    it('stops reporting once an edit is undone', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+        tracker.somebodyElseChanges('changed');
+        expect(await tracker.getChangedFiles(SESSION)).to.have.lengthOf(1);
+
+        tracker.somebodyElseChanges('original');
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+    });
+
+    it('reports a deleted file once, then forgets it and allows writing it', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+
+        tracker.somebodyElseDeletes();
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+        expect(await tracker.isStale(SESSION, FILE)).to.be.false;
+    });
+
+    it('forgets a file that no longer exists when it is recorded', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+        tracker.somebodyElseDeletes();
+
+        // as the change set element does after applying a deletion
+        await tracker.recordRead(SESSION, FILE);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+    });
+
+    it('keeps reporting a file it cannot read, and does not allow overwriting it', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+        tracker.fileChanged(FILE);
+        tracker.readFails = true;
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+        expect(await tracker.isStale(SESSION, FILE)).to.be.true;
+    });
+
+    it('reports a change made while the read recording it was still in flight', async () => {
+        const tracker = new TestFileReadTracker();
+        tracker.duringNextRead = () => {
+            tracker.contents.set(FILE.toString(), 'the user typed something');
+            tracker.documentChanged();
+        };
+
+        // no content handed in, so the tracker reads it itself
+        await tracker.recordRead(SESSION, FILE);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+        expect(await tracker.isStale(SESSION, FILE)).to.be.true;
+    });
+
+    it('records nothing when the content cannot be read', async () => {
+        const tracker = new TestFileReadTracker();
+        tracker.readFails = true;
+
+        await tracker.recordRead(SESSION, FILE);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+    });
+
+    it('treats a write by another session as an external change', async () => {
+        const tracker = new TestFileReadTracker();
+        await tracker.agentRead();
+        await tracker.agentRead(FILE, OTHER_SESSION);
+
+        tracker.somebodyElseChanges('written by the other session');
+        await tracker.recordRead(OTHER_SESSION, FILE);
+
+        expect(await tracker.getChangedFiles(OTHER_SESSION)).to.be.empty;
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal([FILE_LABEL]);
+    });
+
+    it('compares a file the read tools decode as UTF-16, not as UTF-8', async () => {
+        const tracker = new TestFileReadTracker();
+        tracker.encoding = 'utf16le'; // as a Windows-written `.ps1` is stored
+        await tracker.agentRead();
+
+        tracker.fileChanged(FILE);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.be.empty;
+    });
+
+    describe('naming changed files', () => {
+
+        /** How the notice names `file` after it changed, in a workspace with the given extra roots. */
+        async function nameOf(file: URI, ...extraRoots: URI[]): Promise<string[]> {
+            const tracker = new TestFileReadTracker();
+            tracker.roots.push(...extraRoots);
+            tracker.contents.set(file.toString(), 'original');
+            await tracker.agentRead(file);
+            tracker.somebodyElseChanges('changed', file);
+            return tracker.getChangedFiles(SESSION);
+        }
+
+        it('names a file by the root it is in', async () => {
+            expect(await nameOf(new URI('file:///elsewhere/lib/b.ts'), new URI('file:///elsewhere/lib'))).to.deep.equal(['lib/b.ts']);
+        });
+
+        it('names a file by its root when that root is listed twice', async () => {
+            expect(await nameOf(FILE, ROOT)).to.deep.equal([FILE_LABEL]);
+        });
+
+        it('names a file by uri when two roots share the name it would use', async () => {
+            expect(await nameOf(FILE, new URI('file:///elsewhere/workspace'))).to.deep.equal([FILE.toString()]);
+        });
+
+        it('names a file by uri when it is outside every root', async () => {
+            expect(await nameOf(new URI('file:///etc/hosts'))).to.deep.equal(['file:///etc/hosts']);
+        });
+    });
+
+    it('evicts the least recently recorded file beyond the per-session limit', async () => {
+        const tracker = new TestFileReadTracker();
+        const files = ['a', 'b', 'c'].map(name => new URI(`file:///workspace/${name}.ts`));
+        for (const uri of files) {
+            tracker.contents.set(uri.toString(), 'original');
+            await tracker.agentRead(uri);
+        }
+
+        files.forEach(uri => tracker.somebodyElseChanges('changed', uri));
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal(['workspace/b.ts', 'workspace/c.ts']);
+    });
+
+    it('keeps a re-read file tracked, evicting the one untouched for longest', async () => {
+        const tracker = new TestFileReadTracker();
+        const [a, b, c] = ['a', 'b', 'c'].map(name => new URI(`file:///workspace/${name}.ts`));
+        [a, b, c].forEach(uri => tracker.contents.set(uri.toString(), 'original'));
+        await tracker.agentRead(a);
+        await tracker.agentRead(b);
+        await tracker.agentRead(a);
+        await tracker.agentRead(c);
+
+        tracker.somebodyElseChanges('changed', a);
+        tracker.somebodyElseChanges('changed', b);
+
+        expect(await tracker.getChangedFiles(SESSION)).to.deep.equal(['workspace/a.ts']);
+    });
+});