@myagentroam/node 0.11.1 → 0.11.3

package/dist/service/run-event-service.js

@@ -159,8 +159,15 @@ export class RunEventService {
         const createdTurn = targetsCurrentTurn && targetTurn === undefined && currentTurn === undefined
             ? this.options.runtime.conversationTurnForRun(runId)
             : undefined;
+        const projectedTurn = this.options.runtime.conversationTurnForExecution(executionId) ??
+            this.options.runtime.conversationTurnForRun(runId);
+        const previousGroups = new Map(targetTurn?.items.map((item) => [item.id, item.processGroup]));
+        const correctedGroups = projectedTurn !== undefined &&
+            projectedTurn.items.some((item) => previousGroups.has(item.id) &&
+                (previousGroups.get(item.id)?.id !== item.processGroup?.id ||
+                    previousGroups.get(item.id)?.isStart !== item.processGroup?.isStart));
         if (targetsCurrentTurn)
-            this.options.emitWorkbench('conversation', createdTurn === undefined
+            this.options.emitWorkbench('conversation', createdTurn === undefined && !correctedGroups
                 ? {
                     event: {
                         ...event,
@@ -168,7 +175,7 @@ export class RunEventService {
                         createdAt: recorded?.createdAt ?? Date.now()
                     }
                 }
-                : { turn: createdTurn });
+                : { turn: createdTurn ?? projectedTurn });
         else {
             const projectedTurn = this.options.runtime.conversationTurnForExecution(executionId);
             if (projectedTurn !== undefined)

package/dist/service/skill-directory-service.js

@@ -22,11 +22,11 @@ export class SkillDirectoryService {
                 : agents.map(withoutSource)
         };
     }
-    async inspectWorkspace(workspace) {
+    async inspectWorkspace(workspace, includeParentRepository = true) {
         const agents = await scanRoot(path.join(workspace, '.agents', 'skills'), 'AGENTS');
         const claude = await scanRoot(path.join(workspace, '.claude', 'skills'), 'CLAUDE');
         const skills = mergeWorkspaceCopies(agents, claude);
-        const gitExcludeBroken = await hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name));
+        const gitExcludeBroken = await hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name), includeParentRepository);
         return {
             targetKind: 'WORKSPACE',
             compatibilityMode: 'MANAGED_COPY',

package/dist/service/skill-install-service.js

@@ -4,6 +4,7 @@ import { promisify } from 'node:util';
 import { lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
+import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
 import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
 export class SkillInstallService {
     async recoverNodeHome(home) {
@@ -59,15 +60,15 @@ export class SkillInstallService {
         await mkdir(claudeRoot, { recursive: true });
         await assertContainedDirectory(workspace, agentsRoot);
         await assertContainedDirectory(workspace, claudeRoot);
-        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateWorkspaceSkillGitExclude(workspace, name, true), () => updateWorkspaceSkillGitExclude(workspace, name, false));
+        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateWorkspaceSkillGitExclude(workspace, name, true, options.includeParentRepository ?? true), () => updateWorkspaceSkillGitExclude(workspace, name, false, options.includeParentRepository ?? true));
     }
-    async removeWorkspace(workspace, name) {
+    async removeWorkspace(workspace, name, includeParentRepository = true) {
         assertName(name);
         const agentsRoot = path.join(workspace, '.agents', 'skills');
         const claudeRoot = path.join(workspace, '.claude', 'skills');
         await assertExistingContainedDirectory(workspace, agentsRoot);
         await assertExistingContainedDirectory(workspace, claudeRoot);
-        await removePair(agentsRoot, claudeRoot, name, () => updateWorkspaceSkillGitExclude(workspace, name, false), () => updateWorkspaceSkillGitExclude(workspace, name, true));
+        await removePair(agentsRoot, claudeRoot, name, () => updateWorkspaceSkillGitExclude(workspace, name, false, includeParentRepository), () => updateWorkspaceSkillGitExclude(workspace, name, true, includeParentRepository));
     }
     async removeNodeHome(home, name) {
         assertName(name);
@@ -81,7 +82,7 @@ export class SkillInstallService {
         else
             await removeSingle(agentsRoot, name);
     }
-    async repairWorkspaceGitExclude(workspace) {
+    async repairWorkspaceGitExclude(workspace, includeParentRepository = true) {
         const root = path.join(workspace, '.agents', 'skills');
         const names = new Set();
         try {
@@ -101,13 +102,20 @@ export class SkillInstallService {
             if (!isMissing(error))
                 throw error;
         }
-        await rewriteWorkspaceGitExclude(workspace, names);
+        await rewriteWorkspaceGitExclude(workspace, names, includeParentRepository);
     }
 }
 export async function workspaceSkillTracked(workspace, name) {
     assertName(name);
-    if (!(await exists(path.join(workspace, '.git'))))
-        return false;
+    try {
+        await resolveWorkspaceGitRoot(workspace);
+    }
+    catch (error) {
+        if ((error instanceof GitCommandError && error.code === 128) ||
+            error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
     try {
         const result = await promisify(execFile)('git', ['-C', workspace, 'ls-files', '--', `.agents/skills/${name}`, `.claude/skills/${name}`], { timeout: 5_000, windowsHide: true });
         return result.stdout.trim() !== '';

package/dist/service/skill-node-operation-service.js

@@ -28,14 +28,14 @@ export class SkillNodeOperationService {
             'workspace.skills.inspect': async (data) => {
                 const workspace = this.workspacePath(record(data)['workspaceId']);
                 await this.installer.recoverWorkspace(workspace);
-                return this.directories.inspectWorkspace(workspace);
+                return this.directories.inspectWorkspace(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
             },
             'workspace.skills.install': (data) => this.install('WORKSPACE', data),
             'workspace.skills.remove': (data) => this.remove('WORKSPACE', data),
             'workspace.skills.git-exclude-repair': async (data) => {
                 const workspace = this.workspacePath(record(data)['workspaceId']);
                 await this.installer.recoverWorkspace(workspace);
-                await this.installer.repairWorkspaceGitExclude(workspace);
+                await this.installer.repairWorkspaceGitExclude(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
                 return { repaired: true };
             },
             'skill.install.job.get': (data) => this.job(data)
@@ -113,7 +113,8 @@ export class SkillNodeOperationService {
             await this.installer.installNodeHome(homedir(), input.name, bundle, input.metadata);
         else
             await this.installer.installWorkspace(input.workspace, input.name, bundle, input.metadata, {
-                confirmTracked: true
+                confirmTracked: true,
+                includeParentRepository: this.database().getWorkspaceByPath(input.workspace)?.includeParentRepository ?? true
             });
     }
     async remove(target, data) {
@@ -131,7 +132,7 @@ export class SkillNodeOperationService {
             }
             else {
                 await this.installer.recoverWorkspace(workspace);
-                await this.installer.removeWorkspace(workspace, name);
+                await this.installer.removeWorkspace(workspace, name, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
             }
         }
         finally {

package/dist/service/workbench-event-projection.js

@@ -90,6 +90,8 @@ export function projectWorkbenchPayload(queries, category, payload) {
                     payload: item.payload,
                     startedAt: item.startedAt,
                     completedAt: item.completedAt,
+                    parentItemId: item.parentItemId,
+                    ...(item.processGroup === undefined ? {} : { processGroup: item.processGroup }),
                     segmentId: segment.id,
                     segmentIndex: segment.index
                 }

package/dist/service/workbench-manifest-service.js

@@ -29,7 +29,7 @@ export class WorkbenchManifestService {
             conversation: {
                 available: true,
                 reasonCode: null,
-                itemVersions: [1],
+                itemVersions: [2],
                 supportsSessionCursor: true,
                 supportsHistoryPaging: true,
                 supportsItemFinalSnapshots: true,

package/dist/service/workspace-change-service.js

@@ -2,7 +2,7 @@ import { lstat } from 'node:fs/promises';
 import { basename, posix, resolve } from 'node:path';
 import { publicErrorMessage } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository } from '../workspace.js';
+import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository, resolveWorkspaceGitRoot } from '../workspace.js';
 const CACHE_TTL_MS = 5_000;
 const REPOSITORY_READ_CONCURRENCY = 4;
 const WORKTREE_READ_CONCURRENCY = 4;
@@ -13,6 +13,9 @@ export class WorkspaceChangeService {
     constructor(state) {
         this.state = state;
     }
+    revision(workspaceId) {
+        return this.state.changesVersions.get(workspaceId) ?? 0;
+    }
     invalidate(workspaceId) {
         this.state.changesReads.delete(workspaceId);
         this.state.changesCache.delete(workspaceId);
@@ -34,7 +37,9 @@ export class WorkspaceChangeService {
             return existing;
         // Invalidation may arrive during this shared read; its old result must not repopulate the cache.
         const version = this.state.changesVersions.get(workspace.id) ?? 0;
-        const request = this.state.changesLimiter.run(async () => {
+        const request = this.state.changesLimiter
+            .run(async () => {
+            const repositoryRoot = await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true);
             const startedAt = performance.now();
             const errors = [];
             const failure = (code, error) => ({
@@ -66,7 +71,7 @@ export class WorkspaceChangeService {
             };
             const readRepository = async (repositoryPath, repositoryOverride) => {
                 const repository = repositoryOverride ??
-                    (await resolveGitRepository(workspace.path, repositoryPath, [repositoryPath]));
+                    (await resolveGitRepository(repositoryRoot, repositoryPath, [repositoryPath]));
                 if (repositoryPath !== '' || repositoryOverride !== undefined) {
                     const marker = await lstat(resolve(repository, '.git'));
                     if (marker.isSymbolicLink() || (!marker.isFile() && !marker.isDirectory()))
@@ -89,19 +94,14 @@ export class WorkspaceChangeService {
                     changes
                 };
             };
-            const root = await readRepository('').catch((error) => {
-                if (error?.code === 'ENOENT' &&
-                    error.syscall?.startsWith('spawn') === true)
-                    throw new Error('GIT_NOT_FOUND');
-                throw error;
-            });
+            const root = await readRepository('');
             const children = [];
             let parents = [''];
             let submodulesLimited = false;
             while (parents.length > 0 && !submodulesLimited) {
                 const discovered = await mapWithConcurrency(parents, REPOSITORY_READ_CONCURRENCY, async (parent) => {
                     try {
-                        const path = await resolveGitRepository(workspace.path, parent, [parent]);
+                        const path = await resolveGitRepository(repositoryRoot, parent, [parent]);
                         return (await listGitSubmodules(path)).map((entry) => ({
                             ...entry,
                             path: parent === '' ? entry.path : `${parent}/${entry.path}`
@@ -152,7 +152,7 @@ export class WorkspaceChangeService {
                     .map((entry) => entry.repositoryPath);
             }
             children.sort((left, right) => left.repositoryPath.localeCompare(right.repositoryPath));
-            const worktreeList = await listGitWorktrees(workspace.path).catch((error) => {
+            const worktreeList = await listGitWorktrees(repositoryRoot).catch((error) => {
                 discoveryFailure('WORKTREE', '', 'GIT_WORKTREE_DISCOVERY_FAILED', error);
                 return { entries: [], truncated: false };
             });
@@ -229,6 +229,13 @@ export class WorkspaceChangeService {
                 diffAvailable: true
             });
             const value = {
+                repositoryRoot,
+                workspace: {
+                    id: workspace.id,
+                    path: workspace.path,
+                    kind: 'GIT_WORKSPACE',
+                    gitSummary: { branch: root.branch, repositoryRoot }
+                },
                 partial: errors.length > 0 ||
                     children.some((group) => group.status === 'UNAVAILABLE') ||
                     linkedRepositories.some((group) => group.status === 'UNAVAILABLE') ||
@@ -240,7 +247,7 @@ export class WorkspaceChangeService {
                     {
                         ...root,
                         source: 'ROOT',
-                        physicalPath: currentWorktree?.path ?? workspace.path,
+                        physicalPath: currentWorktree?.path ?? repositoryRoot,
                         current: true,
                         ...(currentWorktree === undefined ? {} : { head: currentWorktree.head }),
                         status: root.dirty ? 'DIRTY' : 'CLEAN',
@@ -267,8 +274,17 @@ export class WorkspaceChangeService {
                     durationMs: Math.round(performance.now() - startedAt)
                 });
             if ((this.state.changesVersions.get(workspace.id) ?? 0) === version)
-                this.state.changesCache.set(workspace.id, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+                this.state.changesCache.set(workspace.id, {
+                    value,
+                    expiresAt: Date.now() + CACHE_TTL_MS
+                });
             return value;
+        })
+            .catch((error) => {
+            if (error?.code === 'ENOENT' &&
+                error.syscall?.startsWith('spawn') === true)
+                throw new Error('GIT_NOT_FOUND');
+            throw error;
         });
         this.state.changesReads.set(workspace.id, request);
         try {

package/dist/service/workspace-file-service.js

@@ -176,7 +176,9 @@ export class WorkspaceFileService {
         return { size: metadata.size, revision: metadata.sourceRevision };
     }
     async write(workspace, input) {
-        if (typeof input.path !== 'string' ||
+        if (input.repositoryPath !== undefined ||
+            input.worktreePath !== undefined ||
+            typeof input.path !== 'string' ||
             typeof input.content !== 'string' ||
             typeof input.expectedRevision !== 'string')
             throw new Error('FILE_WRITE_INVALID');

package/dist/service/workspace-git-exclude-service.js

@@ -1,53 +1,91 @@
 import { randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
-import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
 const MAR_TEMP_DIRECTORY = '/.mar/';
 const BLOCK_BEGIN = '# BEGIN MyAgentRoam';
 const BLOCK_END = '# END MyAgentRoam';
 const LEGACY_BLOCK_BEGIN = '# BEGIN MyAgentRoam Skills';
 const LEGACY_BLOCK_END = '# END MyAgentRoam Skills';
-export async function ensureWorkspaceGitExclude(workspace) {
-    await mutateGitExclude(workspace, () => undefined);
+export async function ensureWorkspaceGitExclude(workspace, includeParentRepository = true) {
+    await mutateGitExclude(workspace, () => undefined, includeParentRepository);
 }
-export async function updateWorkspaceSkillGitExclude(workspace, name, add) {
-    await mutateGitExclude(workspace, (entries) => {
+export async function updateWorkspaceSkillGitExclude(workspace, name, add, includeParentRepository = true) {
+    await mutateGitExclude(workspace, (entries, prefix) => {
         for (const root of ['.agents', '.claude']) {
-            const line = `/${root}/skills/${name}/`;
+            const line = `${prefix}${root}/skills/${name}/`;
             if (add)
                 entries.add(line);
             else
                 entries.delete(line);
         }
-    });
+    }, includeParentRepository);
 }
-export async function rewriteWorkspaceGitExclude(workspace, names) {
-    await mutateGitExclude(workspace, (entries) => {
-        entries.clear();
+export async function rewriteWorkspaceGitExclude(workspace, names, includeParentRepository = true) {
+    await mutateGitExclude(workspace, (entries, prefix) => {
+        for (const entry of entries)
+            if (['.agents', '.claude'].some((root) => entry.startsWith(`${prefix}${root}/skills/`)))
+                entries.delete(entry);
         for (const name of names)
             for (const root of ['.agents', '.claude'])
-                entries.add(`/${root}/skills/${name}/`);
-    });
+                entries.add(`${prefix}${root}/skills/${name}/`);
+    }, includeParentRepository);
 }
-export async function hasBrokenWorkspaceSkillGitExclude(workspace, names) {
-    if (!(await exists(path.join(workspace, '.git'))))
-        return false;
+export async function hasBrokenWorkspaceSkillGitExclude(workspace, names, includeParentRepository = true) {
     try {
-        const exclude = await resolveGitExclude(workspace);
+        const target = await gitExcludeTarget(workspace, includeParentRepository);
+        if (target === undefined)
+            return false;
+        const { exclude, prefix } = target;
         const content = await readFile(exclude, 'utf8');
         return names
-            .flatMap((name) => [`/.agents/skills/${name}/`, `/.claude/skills/${name}/`])
+            .flatMap((name) => [`${prefix}.agents/skills/${name}/`, `${prefix}.claude/skills/${name}/`])
             .some((entry) => !content.includes(entry));
     }
     catch {
         return true;
     }
 }
-async function mutateGitExclude(workspace, mutate) {
-    if (!(await exists(path.join(workspace, '.git'))))
+const mutationTails = new Map();
+async function gitExcludeTarget(workspace, includeParentRepository) {
+    let root;
+    try {
+        root = await resolveWorkspaceGitRoot(workspace, includeParentRepository);
+    }
+    catch (error) {
+        if ((error instanceof GitCommandError && error.code === 128) ||
+            (error instanceof Error && error.message === 'WORKSPACE_NOT_GIT') ||
+            error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const relative = path
+        .relative(root, await realpath(workspace))
+        .split(path.sep)
+        .join('/');
+    const escaped = relative.replace(/[\\*?\[\]#! ]/g, '\\$&');
+    return { exclude: await resolveGitExclude(root), prefix: relative === '' ? '/' : `/${escaped}/` };
+}
+async function mutateGitExclude(workspace, mutate, includeParentRepository) {
+    const target = await gitExcludeTarget(workspace, includeParentRepository);
+    if (target === undefined)
         return;
-    const exclude = await resolveGitExclude(workspace);
+    const { exclude, prefix } = target;
+    const request = (mutationTails.get(exclude) ?? Promise.resolve())
+        .catch(() => undefined)
+        .then(() => writeGitExclude(exclude, (entries) => mutate(entries, prefix)));
+    mutationTails.set(exclude, request);
+    try {
+        await request;
+    }
+    finally {
+        if (mutationTails.get(exclude) === request)
+            mutationTails.delete(exclude);
+    }
+}
+async function writeGitExclude(exclude, mutate) {
     await mkdir(path.dirname(exclude), { recursive: true });
     let content = '';
     try {
@@ -62,7 +100,7 @@ async function mutateGitExclude(workspace, mutate) {
     }
     const pattern = managedBlockPattern();
     const existing = [...content.matchAll(pattern)].map((match) => match[0]).join('\n');
-    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/.')));
+    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/')));
     entries.delete(MAR_TEMP_DIRECTORY);
     mutate(entries);
     const block = entries.size === 0 ? '' : `${BLOCK_BEGIN}\n${[...entries].sort().join('\n')}\n${BLOCK_END}\n`;
@@ -97,17 +135,6 @@ async function resolveGitExclude(workspace) {
         throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
     }
 }
-async function exists(value) {
-    try {
-        await lstat(value);
-        return true;
-    }
-    catch (error) {
-        if (isMissing(error))
-            return false;
-        throw error;
-    }
-}
 function isMissing(error) {
     return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
 }

package/dist/service/workspace-service.js

@@ -1,4 +1,4 @@
-import { rmdir } from 'node:fs/promises';
+import { realpath, rmdir } from 'node:fs/promises';
 import { createWorkspaceDirectory, inspectWorkspace, listWorkspaceDirectories } from '../workspace.js';
 import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 import { workspaceGitSettingsSchema } from '@myagentroam/protocol';
@@ -7,11 +7,13 @@ export class WorkspaceService {
     config;
     runtime;
     onRemoved;
-    constructor(database, config, runtime, onRemoved) {
+    onGitPolicyChanged;
+    constructor(database, config, runtime, onRemoved, onGitPolicyChanged = () => undefined) {
         this.database = database;
         this.config = config;
         this.runtime = runtime;
         this.onRemoved = onRemoved;
+        this.onGitPolicyChanged = onGitPolicyChanged;
     }
     operations() {
         return {
@@ -36,14 +38,28 @@ export class WorkspaceService {
             const path = typeof input.createDirectoryName === 'string'
                 ? (createdPath = await createWorkspaceDirectory(input.path, input.createDirectoryName, this.config().allowedRoots))
                 : input.path;
-            const inspected = await inspectWorkspace(path, this.config().allowedRoots);
-            await ensureWorkspaceGitExclude(inspected.path);
+            const canonicalPath = await realpath(path);
+            const current = this.database().getWorkspaceByPath(canonicalPath);
+            const includeParentRepository = current?.includeParentRepository ?? true;
+            const inspected = await inspectWorkspace(canonicalPath, this.config().allowedRoots, includeParentRepository);
+            let latest = this.database().getWorkspaceByPath(canonicalPath);
+            if (latest !== undefined &&
+                (latest.includeParentRepository ?? true) !== includeParentRepository)
+                return { workspace: latest };
+            if (inspected.kind === 'GIT_WORKSPACE') {
+                await ensureWorkspaceGitExclude(inspected.path, includeParentRepository);
+                latest = this.database().getWorkspaceByPath(canonicalPath);
+                if (latest !== undefined &&
+                    (latest.includeParentRepository ?? true) !== includeParentRepository)
+                    return { workspace: latest };
+            }
             return {
                 workspace: this.database().saveWorkspace({
                     path: inspected.path,
                     kind: inspected.kind,
                     gitSummary: inspected.gitSummary ?? null,
-                    preserveGitConfig: input.preserveGitConfig === true
+                    preserveGitConfig: input.preserveGitConfig === true,
+                    includeParentRepository
                 })
             };
         }
@@ -80,13 +96,22 @@ export class WorkspaceService {
         if (current === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         if (!update)
-            return { preserveGitConfig: current.preserveGitConfig ?? true };
+            return {
+                preserveGitConfig: current.preserveGitConfig ?? true,
+                includeParentRepository: current.includeParentRepository ?? true
+            };
         const parsed = workspaceGitSettingsSchema.safeParse({
-            preserveGitConfig: input.preserveGitConfig
+            preserveGitConfig: input.preserveGitConfig,
+            includeParentRepository: input.includeParentRepository
         });
         if (!parsed.success)
             throw new Error('GIT_CONFIGURATION_INVALID');
-        const result = this.database().setWorkspaceGitPolicy(input.workspaceId, parsed.data.preserveGitConfig);
-        return { preserveGitConfig: result.preserveGitConfig };
+        const result = this.database().setWorkspaceGitPolicy(input.workspaceId, parsed.data.preserveGitConfig, parsed.data.includeParentRepository);
+        if (result.includeParentRepository !== current.includeParentRepository)
+            this.onGitPolicyChanged(current.id);
+        return {
+            preserveGitConfig: result.preserveGitConfig,
+            includeParentRepository: result.includeParentRepository
+        };
     }
 }

package/dist/service/workspace-watch-snapshot-service.js

@@ -15,15 +15,23 @@ export class WorkspaceWatchSnapshotService {
         if (watch.topics.files !== undefined)
             this.ensureFilesRefreshTimer();
         await Promise.all(this.subscribedTopics(watch).map(async (topic) => {
+            const revision = this.readRevision(workspace.id, topic);
             try {
                 const payload = await this.read(workspace, topic, watch);
                 if (!this.matches(workspace.id, watch))
                     return;
+                if (revision !== this.readRevision(workspace.id, topic)) {
+                    void this.invalidate(workspace.id, topic);
+                    return;
+                }
                 this.signatures.set(this.viewKey(workspace.id, topic, watch), signature(payload));
                 this.deliver(workspace, watch, topic, payload);
             }
             catch {
-                this.fail(workspace.id, watch, topic);
+                if (revision === this.readRevision(workspace.id, topic))
+                    this.fail(workspace.id, watch, topic);
+                else
+                    void this.invalidate(workspace.id, topic);
             }
         }));
     }
@@ -119,7 +127,22 @@ export class WorkspaceWatchSnapshotService {
             const first = subscribers[0];
             if (first === undefined)
                 return;
-            const payload = await this.read(workspace, topic, first);
+            const revision = this.readRevision(workspaceId, topic);
+            let payload;
+            try {
+                payload = await this.read(workspace, topic, first);
+            }
+            catch (error) {
+                if (revision !== this.readRevision(workspaceId, topic)) {
+                    void this.invalidate(workspaceId, topic);
+                    return;
+                }
+                throw error;
+            }
+            if (revision !== this.readRevision(workspaceId, topic)) {
+                void this.invalidate(workspaceId, topic);
+                return;
+            }
             const activeSubscribers = subscribers.filter((watch) => this.matches(workspaceId, watch));
             if (activeSubscribers.length === 0)
                 return;
@@ -157,7 +180,7 @@ export class WorkspaceWatchSnapshotService {
     read(workspace, topic, watch) {
         const key = topic === 'files'
             ? `${workspace.id}:files:${JSON.stringify(watch.topics.files)}`
-            : `${workspace.id}:${topic}`;
+            : `${workspace.id}:${topic}:${this.readRevision(workspace.id, topic)}`;
         const active = this.reads.get(key);
         if (active !== undefined)
             return active;
@@ -166,8 +189,12 @@ export class WorkspaceWatchSnapshotService {
             : topic === 'changes'
                 ? workspace.kind === 'GIT_WORKSPACE'
                     ? this.options.changes.current(workspace)
-                    : Promise.resolve(null)
-                : this.options.files.list(workspace, watch.topics.files).then((files) => ({ files }))).finally(() => {
+                    : Promise.resolve(workspace.includeParentRepository === false
+                        ? { workspace, changes: [], repositories: [] }
+                        : null)
+                : this.options.files
+                    .list(workspace, watch.topics.files)
+                    .then((files) => ({ files, workspace: this.options.requireWorkspace(workspace.id) }))).finally(() => {
             if (this.reads.get(key) === read)
                 this.reads.delete(key);
         });
@@ -181,6 +208,9 @@ export class WorkspaceWatchSnapshotService {
         this.signatures.set(key, next);
         return true;
     }
+    readRevision(workspaceId, topic) {
+        return topic === 'changes' ? this.options.changes.revision(workspaceId) : 0;
+    }
     viewKey(workspaceId, topic, watch) {
         return topic === 'files'
             ? `${workspaceId}:files:${JSON.stringify(watch.topics.files)}`