@myagentroam/node 0.11.0 → 0.11.2

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

@@ -0,0 +1,112 @@
+import { conversationSegmentIdentityForItem, conversationSegments } from './conversation-segment-service.js';
+import { runConversationItemId } from '../runtime-state.js';
+import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../runner/codex/conversation-parser.js';
+export function workbenchPayloadSessionId(getRun, category, payload) {
+    if (!isPlainRecord(payload))
+        return undefined;
+    if (category === 'session') {
+        if (isPlainRecord(payload.session)) {
+            const id = payload.session.id;
+            if (typeof id === 'string')
+                return id;
+        }
+        return typeof payload.sessionId === 'string' ? payload.sessionId : undefined;
+    }
+    if (category === 'run' && isNodeAgentRun(payload.run))
+        return payload.run.sessionId;
+    if (category === 'conversation') {
+        if (isNodeConversationTurn(payload.turn))
+            return payload.turn.sessionId;
+        if (typeof payload.sessionId === 'string')
+            return payload.sessionId;
+        if (isPlainRecord(payload.event)) {
+            const runId = payload.event.runId;
+            return typeof runId === 'string' ? getRun(runId)?.sessionId : undefined;
+        }
+    }
+    if (category === 'queue') {
+        const id = payload.sessionId;
+        return typeof id === 'string' ? id : undefined;
+    }
+    return undefined;
+}
+/** Projects normalized runtime facts without publishing or mutating them. */
+export function projectWorkbenchPayload(queries, category, payload) {
+    if (category === 'conversation' &&
+        isPlainRecord(payload) &&
+        isPlainRecord(payload.event) &&
+        payload.event.eventType !== 'notification') {
+        const runId = typeof payload.event.runId === 'string' ? payload.event.runId : undefined;
+        const sequence = typeof payload.event.sequence === 'number' ? payload.event.sequence : undefined;
+        const turn = runId === undefined ? undefined : queries.conversationTurnForRun(runId);
+        if (turn === undefined)
+            return;
+        const rawPayload = isPlainRecord(payload.event.payload) ? payload.event.payload : undefined;
+        const text = payload.event.eventType === 'text.delta' && typeof rawPayload?.text === 'string'
+            ? rawPayload.text
+            : undefined;
+        const nativeItemId = typeof rawPayload?.itemId === 'string'
+            ? rawPayload.itemId
+            : typeof rawPayload?.approvalId === 'string'
+                ? `approval:${rawPayload.approvalId}`
+                : undefined;
+        const item = text !== undefined && sequence !== undefined
+            ? turn.items.find((candidate) => candidate.kind === 'assistant_message' && candidate.revision === sequence)
+            : nativeItemId === undefined
+                ? undefined
+                : turn.items.find((candidate) => candidate.id ===
+                    runConversationItemId(runId, nativeItemId, typeof rawPayload?.kind === 'string' ? rawPayload.kind : undefined));
+        if (text !== undefined && item?.kind === 'assistant_message') {
+            const segment = conversationSegmentIdentityForItem(turn, item.id, item.kind);
+            payload = {
+                sessionId: turn.sessionId,
+                delta: {
+                    turnId: turn.id,
+                    segmentId: segment.id,
+                    segmentIndex: segment.index,
+                    runId: turn.runId,
+                    itemId: item.id,
+                    text,
+                    createdAt: typeof payload.event.createdAt === 'number'
+                        ? payload.event.createdAt
+                        : (queries.now ?? Date.now)()
+                }
+            };
+        }
+        else if (item !== undefined) {
+            const segment = conversationSegmentIdentityForItem(turn, item.id, item.kind);
+            payload = {
+                sessionId: turn.sessionId,
+                runId: turn.runId,
+                ...(['assistant_message', 'tool_call', 'command_execution', 'file_change'].includes(item.kind) &&
+                    (rawPayload?.append === undefined || item.status !== 'IN_PROGRESS')
+                    ? { progress: queries.progress(turn.sessionId) }
+                    : {}),
+                item: {
+                    turnId: turn.id,
+                    itemId: item.id,
+                    kind: item.kind,
+                    status: item.status,
+                    payload: item.payload,
+                    startedAt: item.startedAt,
+                    completedAt: item.completedAt,
+                    segmentId: segment.id,
+                    segmentIndex: segment.index
+                }
+            };
+        }
+        else {
+            if (payload.event.eventType !== 'run.started' && payload.event.eventType !== 'run.running')
+                return;
+            payload = { turn };
+        }
+    }
+    if (category === 'conversation' && isPlainRecord(payload) && isNodeConversationTurn(payload.turn))
+        return { ...payload, segments: conversationSegments(payload.turn) };
+    if (category === 'run' && isPlainRecord(payload) && isNodeAgentRun(payload.run))
+        return {
+            ...payload,
+            progress: queries.progress(payload.run.sessionId)
+        };
+    return payload;
+}

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

@@ -1,19 +1,36 @@
 import { createEnvelope } from '@myagentroam/protocol';
+import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+import { projectWorkbenchPayload, workbenchPayloadSessionId } from './workbench-event-projection.js';
 export class WorkbenchEventService {
-    send;
-    accepts;
+    options;
     sequence = 0;
-    constructor(send, accepts) {
-        this.send = send;
-        this.accepts = accepts;
+    constructor(options) {
+        this.options = options;
+    }
+    dispatch(category, payload) {
+        payload = projectWorkbenchPayload(this.options.projection, category, payload);
+        if (payload === undefined)
+            return;
+        const event = this.next(category, payload);
+        if (event === undefined)
+            return;
+        const notification = category === 'conversation' &&
+            isPlainRecord(payload) &&
+            isPlainRecord(payload.event) &&
+            payload.event.eventType === 'notification';
+        const sessionId = workbenchPayloadSessionId(this.options.projection.getRun, category, payload);
+        // A Watch owns pending buffering and observation drops as well as ready delivery.
+        if (!notification && sessionId !== undefined && this.options.emitRealtime(sessionId, event))
+            return;
+        this.publish(event);
     }
     next(category, payload) {
-        if (!this.accepts(category, payload))
+        if (!this.options.accepts(category, payload))
             return undefined;
         return { sequence: ++this.sequence, category, payload };
     }
     publish(event) {
-        this.send(createEnvelope('workbench.event', event));
+        this.options.send(createEnvelope('workbench.event', event));
     }
     snapshotSequence() {
         return this.sequence;

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)}`