@myagentroam/node 0.11.35 → 0.11.37

package/dist/workspace/path-access.js

@@ -0,0 +1,184 @@
+import { lstat, realpath, stat } from 'node:fs/promises';
+import { platform as hostPlatform } from 'node:os';
+import { isAbsolute, posix, relative, resolve, sep, win32 } from 'node:path';
+export async function resolveNewWorkspaceEntry(root, requestedPath) {
+    const normalized = requestedPath.replaceAll('\\', '/');
+    const segments = normalized.split('/');
+    const name = segments.at(-1);
+    if (requestedPath.includes('\0') ||
+        normalized.startsWith('/') ||
+        isAbsolute(requestedPath) ||
+        win32.isAbsolute(normalized) ||
+        name === undefined ||
+        name.length === 0 ||
+        segments.some(invalidWorkspaceMutationSegment))
+        throw new Error('FILE_PATH_ESCAPE');
+    const parentPath = segments.length === 1 ? '.' : segments.slice(0, -1).join('/');
+    await assertWorkspaceMutationPathHasNoSymlinks(root, parentPath);
+    const parent = await resolveWorkspaceEntryFromCanonicalRoot(root, parentPath, true);
+    const target = resolve(parent, name);
+    try {
+        await lstat(target);
+        throw new Error('FILE_ALREADY_EXISTS');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return target;
+}
+export async function assertWorkspaceMutationPathHasNoSymlinks(root, requestedPath) {
+    const normalized = requestedPath.replaceAll('\\', '/');
+    if (normalized === '.')
+        return;
+    const segments = normalized.split('/');
+    if (requestedPath.includes('\0') ||
+        normalized.startsWith('/') ||
+        isAbsolute(requestedPath) ||
+        win32.isAbsolute(normalized) ||
+        segments.some(invalidWorkspaceMutationSegment))
+        throw new Error('FILE_PATH_ESCAPE');
+    let candidate = root;
+    for (const segment of segments) {
+        candidate = resolve(candidate, segment);
+        const metadata = await lstat(candidate).catch((error) => {
+            if (error.code === 'ENOENT')
+                throw new Error('FILE_NOT_FOUND');
+            throw error;
+        });
+        if (metadata.isSymbolicLink())
+            throw new Error('FILE_PATH_ESCAPE');
+    }
+}
+function invalidWorkspaceMutationSegment(segment) {
+    if (segment.length === 0 || segment === '.' || segment === '..' || segment === '.git')
+        return true;
+    if (hostPlatform() !== 'win32')
+        return false;
+    const normalized = segment.replace(/[. ]+$/u, '').toUpperCase();
+    return (/[<>:"|?*]/u.test(segment) ||
+        /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?$/u.test(normalized));
+}
+export async function resolveRegisteredWorkspaceRoot(workspaceRoot) {
+    const root = await realpath(workspaceRoot);
+    if (normalizeWorkspacePath(root) !== normalizeWorkspacePath(workspaceRoot))
+        throw Object.assign(new Error('WORKSPACE_NOT_ALLOWED'), { code: 'WORKSPACE_NOT_ALLOWED' });
+    return root;
+}
+export class SessionExecutionDirectoryError extends Error {
+    publicMessage;
+    code = 'SESSION_EXECUTION_DIRECTORY_INVALID';
+    publicParameters;
+    constructor(reason, publicMessage, options) {
+        super(publicMessage, options);
+        this.publicMessage = publicMessage;
+        this.publicParameters = { reason };
+    }
+}
+/** Bind ordinary Session execution to one registered Workspace, not all allowed roots. */
+export async function resolveWorkspaceExecutionDirectory(workspaceRoot, cwd) {
+    if (!isAbsolute(cwd) || (process.platform === 'win32' && win32.parse(cwd).root.length <= 1))
+        throw new SessionExecutionDirectoryError('ABSOLUTE_PATH_REQUIRED', 'The execution directory must be an absolute path on this Node.');
+    try {
+        const root = await resolveRegisteredWorkspaceRoot(workspaceRoot);
+        const directory = await realpath(cwd);
+        if (!isWithinAllowedRoot(directory, [root]))
+            throw new SessionExecutionDirectoryError('OUTSIDE_WORKSPACE', 'The execution directory is outside the authorized Workspace.');
+        if (!(await stat(directory)).isDirectory())
+            throw new SessionExecutionDirectoryError('NOT_DIRECTORY', 'The execution directory is not a directory.');
+        return directory;
+    }
+    catch (error) {
+        if (error instanceof SessionExecutionDirectoryError)
+            throw error;
+        const code = error !== null && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        const [reason, message] = code === 'WORKSPACE_NOT_ALLOWED'
+            ? [
+                'WORKSPACE_ROOT_CHANGED',
+                'The registered Workspace root no longer identifies the same directory.'
+            ]
+            : code === 'ENOENT' || code === 'ENOTDIR'
+                ? ['NOT_FOUND', 'The execution directory or Workspace root is unavailable.']
+                : code === 'EACCES' || code === 'EPERM'
+                    ? [
+                        'ACCESS_DENIED',
+                        'The Node account cannot access the execution directory or Workspace root.'
+                    ]
+                    : ['IO_ERROR', 'The execution directory could not be verified.'];
+        throw new SessionExecutionDirectoryError(reason, message, { cause: error });
+    }
+}
+export async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory) {
+    const root = await resolveRegisteredWorkspaceRoot(workspaceRoot);
+    return resolveWorkspaceEntryFromCanonicalRoot(root, requestedPath, directory);
+}
+export async function resolveWorkspaceEntryFromCanonicalRoot(root, requestedPath, directory) {
+    const entry = await resolveWorkspaceEntryMetadata(root, requestedPath);
+    if (directory
+        ? !entry.metadata.isDirectory()
+        : !entry.metadata.isFile() && !entry.metadata.isDirectory())
+        throw new Error(directory ? 'FILE_NOT_DIRECTORY' : 'FILE_NOT_REGULAR');
+    return entry.path;
+}
+export async function resolveWorkspaceEntryMetadata(root, requestedPath) {
+    if (requestedPath.includes('\0') ||
+        requestedPath.length === 0 ||
+        requestedPath.startsWith('/') ||
+        requestedPath.startsWith('\\'))
+        throw new Error('FILE_PATH_ESCAPE');
+    const normalized = requestedPath.replaceAll('\\', '/');
+    if (normalized.split('/').some((segment) => segment === '..' || segment === '.git'))
+        throw new Error('FILE_PATH_ESCAPE');
+    let candidate;
+    try {
+        candidate = await realpath(resolve(root, normalized));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new Error('FILE_NOT_FOUND');
+        throw error;
+    }
+    const pathToCandidate = relative(root, candidate);
+    if (isAbsolute(pathToCandidate) ||
+        pathToCandidate.startsWith('..') ||
+        pathToCandidate === '..' ||
+        pathToCandidate.startsWith(`..${sep}`))
+        throw new Error('FILE_PATH_ESCAPE');
+    const metadata = await lstat(candidate);
+    return { path: candidate, metadata };
+}
+export function normalizeWorkspacePath(input, platform = hostPlatform()) {
+    if (input.length === 0 || input.includes('\u0000')) {
+        throw new Error('WORKSPACE_PATH_INVALID');
+    }
+    if (platform === 'win32') {
+        // Device paths bypass normal Win32 resolution and must never be accepted.
+        if (/^\\\\[?.]/.test(input)) {
+            throw new Error('WORKSPACE_DEVICE_PATH_REJECTED');
+        }
+        const normalized = win32.normalize(input.replaceAll('/', '\\'));
+        if (!win32.isAbsolute(normalized)) {
+            throw new Error('WORKSPACE_PATH_NOT_ABSOLUTE');
+        }
+        // A drive root must remain absolute instead of becoming drive-relative.
+        const root = win32.parse(normalized).root;
+        return (normalized === root ? root : normalized.replace(/\\+$/, '')).toLowerCase();
+    }
+    if (platform !== 'linux' && platform !== 'darwin') {
+        throw new Error('WORKSPACE_PLATFORM_UNSUPPORTED');
+    }
+    const normalized = posix.normalize(input);
+    if (!posix.isAbsolute(normalized)) {
+        throw new Error('WORKSPACE_PATH_NOT_ABSOLUTE');
+    }
+    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+}
+export function isWithinAllowedRoot(target, roots, platform = hostPlatform()) {
+    const normalizedTarget = normalizeWorkspacePath(target, platform);
+    const pathApi = platform === 'win32' ? win32 : posix;
+    return roots.some((root) => {
+        const normalizedRoot = normalizeWorkspacePath(root, platform);
+        const relative = pathApi.relative(normalizedRoot, normalizedTarget);
+        return relative === '' || (!relative.startsWith('..') && !pathApi.isAbsolute(relative));
+    });
+}

package/dist/workspace/utf8.js

@@ -0,0 +1,12 @@
+export function isValidUtf8(source) {
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(source);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isUtf8ContinuationByte(value) {
+    return (value & 0b1100_0000) === 0b1000_0000;
+}

package/dist/{service → workspace}/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, resolveWorkspaceGitRoot } from '../workspace.js';
+import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository, resolveWorkspaceGitRoot } from './git.js';
 const CACHE_TTL_MS = 5_000;
 const REPOSITORY_READ_CONCURRENCY = 4;
 const WORKTREE_READ_CONCURRENCY = 4;
@@ -10,35 +10,35 @@ const CHANGE_VISIBILITY_CONCURRENCY = 16;
 const SUBMODULE_LIMIT = 128;
 const CHANGE_RESULT_LIMIT = 1000;
 export class WorkspaceChangeService {
-    state;
-    constructor(state) {
-        this.state = state;
-    }
+    changesReads = new Map();
+    changesCache = new Map();
+    changesVersions = new Map();
+    changesLimiter = new AsyncLimiter(3);
     revision(workspaceId) {
-        return this.state.changesVersions.get(workspaceId) ?? 0;
+        return this.changesVersions.get(workspaceId) ?? 0;
     }
     invalidate(workspaceId) {
-        this.state.changesReads.delete(workspaceId);
-        this.state.changesCache.delete(workspaceId);
-        this.state.changesVersions.set(workspaceId, (this.state.changesVersions.get(workspaceId) ?? 0) + 1);
+        this.changesReads.delete(workspaceId);
+        this.changesCache.delete(workspaceId);
+        this.changesVersions.set(workspaceId, (this.changesVersions.get(workspaceId) ?? 0) + 1);
     }
     clear() {
-        this.state.changesReads.clear();
-        this.state.changesCache.clear();
-        this.state.changesVersions.clear();
+        this.changesReads.clear();
+        this.changesCache.clear();
+        this.changesVersions.clear();
     }
     async current(workspace) {
         if (workspace.kind !== 'GIT_WORKSPACE')
             throw new Error('WORKSPACE_NOT_GIT');
-        const cached = this.state.changesCache.get(workspace.id);
+        const cached = this.changesCache.get(workspace.id);
         if (cached !== undefined && cached.expiresAt > Date.now())
             return cached.value;
-        const existing = this.state.changesReads.get(workspace.id);
+        const existing = this.changesReads.get(workspace.id);
         if (existing !== undefined)
             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
+        const version = this.changesVersions.get(workspace.id) ?? 0;
+        const request = this.changesLimiter
             .run(async () => {
             const repositoryRoot = await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true);
             const startedAt = performance.now();
@@ -289,8 +289,8 @@ export class WorkspaceChangeService {
                     discoveryErrors: errors.length,
                     durationMs: Math.round(performance.now() - startedAt)
                 });
-            if ((this.state.changesVersions.get(workspace.id) ?? 0) === version)
-                this.state.changesCache.set(workspace.id, {
+            if ((this.changesVersions.get(workspace.id) ?? 0) === version)
+                this.changesCache.set(workspace.id, {
                     value,
                     expiresAt: Date.now() + CACHE_TTL_MS
                 });
@@ -302,13 +302,13 @@ export class WorkspaceChangeService {
                 throw new Error('GIT_NOT_FOUND');
             throw error;
         });
-        this.state.changesReads.set(workspace.id, request);
+        this.changesReads.set(workspace.id, request);
         try {
             return await request;
         }
         finally {
-            if (this.state.changesReads.get(workspace.id) === request)
-                this.state.changesReads.delete(workspace.id);
+            if (this.changesReads.get(workspace.id) === request)
+                this.changesReads.delete(workspace.id);
         }
     }
 }
@@ -324,3 +324,27 @@ async function mapWithConcurrency(values, concurrency, project) {
     }));
     return output;
 }
+class AsyncLimiter {
+    limit;
+    active = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async run(task) {
+        if (this.active < this.limit)
+            this.active += 1;
+        else
+            await new Promise((resolve) => this.waiters.push(resolve));
+        try {
+            return await task();
+        }
+        finally {
+            const next = this.waiters.shift();
+            if (next === undefined)
+                this.active -= 1;
+            else
+                next();
+        }
+    }
+}

package/dist/{service → workspace}/workspace-code-navigation-service.js

@@ -8,12 +8,12 @@ import { supportsSymbolNavigationPath } from '@myagentroam/code-navigation/symbo
 import { workspaceFileReferenceSchema } from '@myagentroam/protocol';
 import { bundledCtagsPath, BUNDLED_CTAGS_VERSION, repairBundledCtagsExecutable } from '../ctags-binary.js';
 import { nodeLog } from '../operational.js';
-import { normalizeWorkspacePath } from '../workspace.js';
-import { pathSpecifierResolver } from './code-navigation/navigation-resolution-registry.js';
-import { reparseFileReference } from './code-navigation/file-reference-parser.js';
-import { acquireBuild, buildIncrementalTags, ensurePrivateDirectory, manifestEntry, readManifest, removeInactiveGenerations, runCtags, sourceDelta, sourceFingerprint, tagsAvailable, tagsPath } from './code-navigation/ctags-index-storage.js';
-import { compareTagNames, firstTagOffset, parseTag, readTagLine } from './code-navigation/ctags-query.js';
-import { compareTargets, containsSymbol, sourceFileFingerprint, targetPreview, validatePathTarget, validateSymbolTarget } from './code-navigation/navigation-target-validator.js';
+import { normalizeWorkspacePath } from './path-access.js';
+import { pathSpecifierResolver } from '../service/code-navigation/navigation-resolution-registry.js';
+import { reparseFileReference } from '../service/code-navigation/file-reference-parser.js';
+import { acquireBuild, buildIncrementalTags, ensurePrivateDirectory, manifestEntry, readManifest, removeInactiveGenerations, runCtags, sourceDelta, sourceFingerprint, tagsAvailable, tagsPath } from '../service/code-navigation/ctags-index-storage.js';
+import { compareTagNames, firstTagOffset, parseTag, readTagLine } from '../service/code-navigation/ctags-query.js';
+import { compareTargets, containsSymbol, sourceFileFingerprint, targetPreview, validatePathTarget, validateSymbolTarget } from '../service/code-navigation/navigation-target-validator.js';
 const INDEX_SCHEMA_VERSION = 1;
 const INDEX_OPTIONS_VERSION = 2;
 const MAX_SOURCE_BYTES = 4 * 1024 * 1024;

package/dist/{service → workspace}/workspace-file-manager-service.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { dirname } from 'node:path';
-import { resolveWorkspaceFileManagerTarget } from '../workspace.js';
+import { resolveWorkspaceFileManagerTarget } from './files.js';
 export function fileManagerInvocation(platform, target) {
     if (platform === 'win32')
         return {

package/dist/{service → workspace}/workspace-file-service.js

@@ -1,23 +1,23 @@
+import { WorkspaceFileIndex } from './file-index.js';
 import { basename, dirname, isAbsolute, relative, resolve, win32 } from 'node:path';
 import { lstat, realpath } from 'node:fs/promises';
 import { imagePreviewOptionsSchema, isComposerAttachmentResourcePath } from '@myagentroam/protocol';
-import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
+import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile } from './files.js';
 import { revealWorkspaceFileInFileManager } from './workspace-file-manager-service.js';
-import { imagePreviews, MAX_IMAGE_PREVIEW_SOURCE_BYTES } from './image-preview-service.js';
+import { imagePreviews, MAX_IMAGE_PREVIEW_SOURCE_BYTES } from '../service/image-preview-service.js';
 const INDEX_CACHE_LIMIT = 32;
 const INDEX_CACHE_BYTE_LIMIT = 128 * 1024 * 1024;
 const INDEX_QUEUE_LIMIT = 16;
 const INDEX_QUEUE_TIMEOUT_MS = 120_000;
 export class WorkspaceFileService {
-    state;
     onInvalidated;
     indexLimits;
     attachmentResource;
+    fileIndexes = new Map();
     mutationTails = new Map();
     indexQueue = [];
     indexRunning = false;
-    constructor(state, onInvalidated, indexLimits = {}, attachmentResource = () => undefined) {
-        this.state = state;
+    constructor(onInvalidated, indexLimits = {}, attachmentResource = () => undefined) {
         this.onInvalidated = onInvalidated;
         this.indexLimits = indexLimits;
         this.attachmentResource = attachmentResource;
@@ -266,7 +266,7 @@ export class WorkspaceFileService {
         }
     }
     index(workspace) {
-        let index = this.state.fileIndexes.get(workspace.id);
+        let index = this.fileIndexes.get(workspace.id);
         if (index === undefined) {
             index = new WorkspaceFileIndex(workspace.path, {
                 ...(this.indexLimits.indexByteLimit === undefined
@@ -276,8 +276,8 @@ export class WorkspaceFileService {
                 onRebuilt: () => this.pruneIndexes(workspace.id)
             });
         }
-        this.state.fileIndexes.delete(workspace.id);
-        this.state.fileIndexes.set(workspace.id, index);
+        this.fileIndexes.delete(workspace.id);
+        this.fileIndexes.set(workspace.id, index);
         this.pruneIndexes(workspace.id);
         return index;
     }
@@ -298,16 +298,16 @@ export class WorkspaceFileService {
         }
     }
     pruneIndexes(protectedId) {
-        let bytes = [...this.state.fileIndexes.values()].reduce((total, index) => total + index.accountedBytes, 0);
+        let bytes = [...this.fileIndexes.values()].reduce((total, index) => total + index.accountedBytes, 0);
         const byteLimit = this.indexLimits.cacheByteLimit ?? INDEX_CACHE_BYTE_LIMIT;
-        for (const [id, index] of this.state.fileIndexes) {
-            if (this.state.fileIndexes.size <= INDEX_CACHE_LIMIT && bytes <= byteLimit)
+        for (const [id, index] of this.fileIndexes) {
+            if (this.fileIndexes.size <= INDEX_CACHE_LIMIT && bytes <= byteLimit)
                 break;
             if (id === protectedId)
                 continue;
             bytes -= index.accountedBytes;
             index.dispose();
-            this.state.fileIndexes.delete(id);
+            this.fileIndexes.delete(id);
         }
         this.prunePreparations();
     }
@@ -357,14 +357,14 @@ export class WorkspaceFileService {
     }
     dispose(workspaceId) {
         if (workspaceId !== undefined) {
-            this.state.fileIndexes.get(workspaceId)?.dispose();
-            this.state.fileIndexes.delete(workspaceId);
+            this.fileIndexes.get(workspaceId)?.dispose();
+            this.fileIndexes.delete(workspaceId);
             this.prunePreparations();
             return;
         }
-        for (const index of this.state.fileIndexes.values())
+        for (const index of this.fileIndexes.values())
             index.dispose();
-        this.state.fileIndexes.clear();
+        this.fileIndexes.clear();
         this.prunePreparations();
     }
 }

package/dist/{service → workspace}/workspace-git-exclude-service.js

@@ -3,7 +3,7 @@ import { execFile } from 'node:child_process';
 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';
+import { GitCommandError, resolveWorkspaceGitRoot } from './git.js';
 const MAR_TEMP_DIRECTORY = '/.mar/';
 const BLOCK_BEGIN = '# BEGIN MyAgentRoam';
 const BLOCK_END = '# END MyAgentRoam';

package/dist/{service → workspace}/workspace-queue-workbench-service.js

@@ -1,6 +1,7 @@
 import { steerComposerMessage } from '@myagentroam/protocol';
-import { isPlainRecord, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
-import { assertQueueItemOwner, assertSessionControlOwner } from './run-ownership-policy.js';
+import { isPlainRecord } from '../util/records.js';
+import { withNonImageAttachmentPrompt } from '../session/attachments.js';
+import { assertQueueItemOwner, assertSessionControlOwner } from '../service/run-ownership-policy.js';
 import { nodeLog } from '../operational.js';
 import { safeErrorCode } from '../util/safe-error.js';
 export class WorkspaceQueueWorkbenchService {

package/dist/{service → workspace}/workspace-session-service.js

@@ -2,38 +2,43 @@ import { nodeLog } from '../operational.js';
 const WATCH_INTERVAL_MS = 30_000;
 const CACHE_TTL_MS = 15_000;
 export class WorkspaceSessionService {
-    state;
     options;
     cacheGenerations = new Map();
     initialReads = new Map();
     incompleteDiscoveries = new Set();
     staleDiscoveries = new Set();
-    constructor(state, options) {
-        this.state = state;
+    sessionWatchTimers = new Map();
+    sessionWatchSignatures = new Map();
+    sessionWatchReads = new Map();
+    sessionCache = new Map();
+    sessionCacheReads = new Map();
+    constructor(options) {
         this.options = options;
     }
+    cachedSnapshot(workspaceId) {
+        return this.sessionCache.get(workspaceId)?.sessions ?? [];
+    }
     ensureWatch(workspaceId) {
-        if (this.state.sessionWatchTimers.has(workspaceId) ||
-            this.state.sessionWatchReads.has(workspaceId))
+        if (this.sessionWatchTimers.has(workspaceId) || this.sessionWatchReads.has(workspaceId))
             return;
         void this.runWatchCycle(workspaceId);
     }
     stopWatch(workspaceId) {
-        const timer = this.state.sessionWatchTimers.get(workspaceId);
+        const timer = this.sessionWatchTimers.get(workspaceId);
         if (timer !== undefined)
             clearTimeout(timer);
-        this.state.sessionWatchTimers.delete(workspaceId);
-        this.state.sessionWatchSignatures.delete(workspaceId);
+        this.sessionWatchTimers.delete(workspaceId);
+        this.sessionWatchSignatures.delete(workspaceId);
     }
     discoveryPending(workspaceId) {
         // Partial cold batches still await native identity confirmation for the remaining Runners.
         return this.incompleteDiscoveries.has(workspaceId);
     }
     async cached(workspaceId) {
-        const cached = this.state.sessionCache.get(workspaceId);
+        const cached = this.sessionCache.get(workspaceId);
         if (cached !== undefined && cached.expiresAt > Date.now())
             return cached.sessions;
-        let discovery = this.state.sessionCacheReads.get(workspaceId);
+        let discovery = this.sessionCacheReads.get(workspaceId);
         if (discovery === undefined) {
             // A retired read must not regain ownership when its Workspace state is reclaimed.
             const generation = Symbol();
@@ -56,8 +61,8 @@ export class WorkspaceSessionService {
             const publish = (sessions, notify = true) => {
                 if (this.cacheGenerations.get(workspaceId) !== generation)
                     return;
-                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
-                this.state.sessionCache.set(workspaceId, {
+                const previous = this.sessionCache.get(workspaceId)?.sessions;
+                this.sessionCache.set(workspaceId, {
                     sessions,
                     expiresAt: this.staleDiscoveries.has(workspaceId) ? 0 : Date.now() + CACHE_TTL_MS
                 });
@@ -70,7 +75,7 @@ export class WorkspaceSessionService {
                 .discover(workspaceId, (runner, sessions) => {
                 if (!acceptingBatches || this.cacheGenerations.get(workspaceId) !== generation)
                     return;
-                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
+                const previous = this.sessionCache.get(workspaceId)?.sessions;
                 const merged = [
                     ...(previous ?? []).filter((session) => session.runner !== runner),
                     ...sessions
@@ -85,7 +90,7 @@ export class WorkspaceSessionService {
                 .then((sessions) => {
                 if (this.cacheGenerations.get(workspaceId) === generation)
                     this.incompleteDiscoveries.delete(workspaceId);
-                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
+                const previous = this.sessionCache.get(workspaceId)?.sessions;
                 notifyCompletion =
                     batchPublished ||
                         (previous !== undefined && sessionSignature(previous) !== sessionSignature(sessions));
@@ -97,16 +102,16 @@ export class WorkspaceSessionService {
                 rejectInitial(error);
                 if (this.cacheGenerations.get(workspaceId) === generation) {
                     nodeLog('native.session.discovery.failed', { workspaceId });
-                    const partial = this.state.sessionCache.get(workspaceId);
+                    const partial = this.sessionCache.get(workspaceId);
                     if (partial !== undefined)
-                        this.state.sessionCache.set(workspaceId, { ...partial, expiresAt: 0 });
+                        this.sessionCache.set(workspaceId, { ...partial, expiresAt: 0 });
                 }
                 throw error;
             })
                 .finally(() => {
                 acceptingBatches = false;
-                if (this.state.sessionCacheReads.get(workspaceId) === read) {
-                    this.state.sessionCacheReads.delete(workspaceId);
+                if (this.sessionCacheReads.get(workspaceId) === read) {
+                    this.sessionCacheReads.delete(workspaceId);
                     // Events during discovery require a trailing refresh, even if its result is unchanged.
                     if (this.staleDiscoveries.delete(workspaceId))
                         notifyCompletion = true;
@@ -115,13 +120,13 @@ export class WorkspaceSessionService {
                     this.initialReads.delete(workspaceId);
                 if (notifyCompletion && this.cacheGenerations.get(workspaceId) === generation)
                     this.options.invalidate(workspaceId);
-                if (!this.state.sessionCacheReads.has(workspaceId) &&
-                    !this.state.sessionCache.has(workspaceId) &&
+                if (!this.sessionCacheReads.has(workspaceId) &&
+                    !this.sessionCache.has(workspaceId) &&
                     this.cacheGenerations.get(workspaceId) === generation)
                     this.cacheGenerations.delete(workspaceId);
             });
             discovery = read;
-            this.state.sessionCacheReads.set(workspaceId, discovery);
+            this.sessionCacheReads.set(workspaceId, discovery);
             // Later Runner failures cannot become unhandled after the first batch was returned.
             void discovery.catch(() => undefined);
         }
@@ -130,14 +135,14 @@ export class WorkspaceSessionService {
         return this.initialReads.get(workspaceId) ?? discovery;
     }
     clear() {
-        for (const timer of this.state.sessionWatchTimers.values())
+        for (const timer of this.sessionWatchTimers.values())
             clearTimeout(timer);
-        this.state.sessionWatchTimers.clear();
-        this.state.sessionWatchSignatures.clear();
-        this.state.sessionWatchReads.clear();
+        this.sessionWatchTimers.clear();
+        this.sessionWatchSignatures.clear();
+        this.sessionWatchReads.clear();
         this.cacheGenerations.clear();
-        this.state.sessionCache.clear();
-        this.state.sessionCacheReads.clear();
+        this.sessionCache.clear();
+        this.sessionCacheReads.clear();
         this.initialReads.clear();
         this.incompleteDiscoveries.clear();
         this.staleDiscoveries.clear();
@@ -147,38 +152,38 @@ export class WorkspaceSessionService {
         this.stopWatch(workspaceId);
     }
     markCacheStale(workspaceId) {
-        const cached = this.state.sessionCache.get(workspaceId);
+        const cached = this.sessionCache.get(workspaceId);
         if (cached !== undefined)
-            this.state.sessionCache.set(workspaceId, { ...cached, expiresAt: 0 });
-        if (this.state.sessionCacheReads.has(workspaceId))
+            this.sessionCache.set(workspaceId, { ...cached, expiresAt: 0 });
+        if (this.sessionCacheReads.has(workspaceId))
             this.staleDiscoveries.add(workspaceId);
     }
     invalidateCache(workspaceId) {
         this.cacheGenerations.delete(workspaceId);
-        this.state.sessionCache.delete(workspaceId);
-        this.state.sessionCacheReads.delete(workspaceId);
+        this.sessionCache.delete(workspaceId);
+        this.sessionCacheReads.delete(workspaceId);
         this.initialReads.delete(workspaceId);
         this.incompleteDiscoveries.delete(workspaceId);
         this.staleDiscoveries.delete(workspaceId);
     }
     async refreshWatch(workspaceId) {
-        const current = this.state.sessionWatchReads.get(workspaceId);
+        const current = this.sessionWatchReads.get(workspaceId);
         if (current !== undefined)
             return current;
-        const refresh = this.performRefresh(workspaceId).finally(() => this.state.sessionWatchReads.delete(workspaceId));
-        this.state.sessionWatchReads.set(workspaceId, refresh);
+        const refresh = this.performRefresh(workspaceId).finally(() => this.sessionWatchReads.delete(workspaceId));
+        this.sessionWatchReads.set(workspaceId, refresh);
         return refresh;
     }
     async runWatchCycle(workspaceId) {
         await this.refreshWatch(workspaceId);
-        if (!this.options.active(workspaceId) || this.state.sessionWatchTimers.has(workspaceId))
+        if (!this.options.active(workspaceId) || this.sessionWatchTimers.has(workspaceId))
             return;
         const timer = setTimeout(() => {
-            this.state.sessionWatchTimers.delete(workspaceId);
+            this.sessionWatchTimers.delete(workspaceId);
             void this.runWatchCycle(workspaceId);
         }, WATCH_INTERVAL_MS);
         timer.unref();
-        this.state.sessionWatchTimers.set(workspaceId, timer);
+        this.sessionWatchTimers.set(workspaceId, timer);
     }
     async performRefresh(workspaceId) {
         if (!this.options.active(workspaceId))
@@ -187,8 +192,8 @@ export class WorkspaceSessionService {
             const signature = JSON.stringify(await this.options.listPage(workspaceId));
             if (!this.options.active(workspaceId))
                 return this.stopWatch(workspaceId);
-            const previous = this.state.sessionWatchSignatures.get(workspaceId);
-            this.state.sessionWatchSignatures.set(workspaceId, signature);
+            const previous = this.sessionWatchSignatures.get(workspaceId);
+            this.sessionWatchSignatures.set(workspaceId, signature);
             if (previous === undefined || previous === signature)
                 return;
             this.options.invalidate(workspaceId);