@myagentroam/node 0.9.4 → 0.9.5

package/dist/service/session-message-service.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, sessionTitleFromFirstMessage, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { personalInstructionsForRunner } from '../util/personal-instructions.js';
 export class SessionMessageService {
     options;
     pendingMessages = new Map();
@@ -29,11 +30,9 @@ export class SessionMessageService {
         if (inlineAttachments.length > 0 && attachmentIds.length > 0)
             throw new Error('MESSAGE_ATTACHMENTS_INVALID');
         const session = await this.options.resolve(input.sessionId);
-        const intent = input.deliveryIntent;
-        if (intent !== undefined &&
-            intent !== 'SEND' &&
-            intent !== 'QUEUE' &&
-            intent !== 'REPLACE_CURRENT')
+        const personalInstructions = personalInstructionsForRunner(input.personalInstructions, session.runner);
+        const intent = input.deliveryIntent ?? 'SEND';
+        if (intent !== 'SEND' && intent !== 'QUEUE' && intent !== 'REPLACE_CURRENT')
             throw new Error('MESSAGE_INVALID');
         const existing = this.options.runtime.findMessageRun(session.id, clientMessageId);
         if (existing !== undefined)
@@ -67,8 +66,8 @@ export class SessionMessageService {
                     .listRunsForSession(session.id)
                     .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
                 const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
-                const queueWasPaused = this.options.runtime.sessionQueue(session.id).paused;
-                const queuedBeforeCreate = this.options.runtime.hasActiveSessionLease(session.id) || intent === 'QUEUE';
+                const queueBeforeCreate = this.options.runtime.sessionQueue(session.id);
+                const leaseWasActive = this.options.runtime.hasActiveSessionLease(session.id);
                 const created = this.options.queue.enqueue({
                     runId,
                     sessionId: session.id,
@@ -84,6 +83,7 @@ export class SessionMessageService {
                     access: session.access,
                     collaborationMode: planActive ? 'plan' : 'default',
                     secretEnvironment,
+                    ...(personalInstructions === undefined ? {} : { personalInstructions }),
                     ...(runner.serviceTier() === 'fast' ? { serviceTier: 'fast' } : {})
                 }, {
                     runId,
@@ -109,25 +109,17 @@ export class SessionMessageService {
                 this.options.emitSession(acceptedSession);
                 this.options.attachments.cache(created.run.id, imageAttachments);
                 void this.options.uploads.consume(attachmentIds).catch(() => undefined);
-                if (queueWasPaused && active === undefined && intent !== 'QUEUE')
-                    this.options.runtime.prioritizeQueuedRun(created.run.id);
-                if (!queueWasPaused || intent !== 'QUEUE')
-                    this.options.runtime.resumeSessionQueue(session.id);
-                if (replaceCurrentRun !== undefined)
-                    this.options.queue.replace(created.run.id, replaceCurrentRun.id);
-                else if (intent !== 'QUEUE' ||
-                    !queuedBeforeCreate ||
-                    !this.options.runtime.hasActiveSessionLease(session.id))
-                    this.options.queue.schedule(session.id);
-                this.options.emitQueue(session.workspaceId, session.id);
+                const delivery = this.options.queue.settleEnqueue({
+                    runId: created.run.id,
+                    intent,
+                    queueBefore: queueBeforeCreate,
+                    leaseWasActive,
+                    ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
+                });
                 return {
                     session: this.options.present(acceptedSession),
                     run: created.run,
-                    delivery: replaceCurrentRun !== undefined
-                        ? 'RESTARTING'
-                        : queuedBeforeCreate
-                            ? 'QUEUED'
-                            : 'STARTED',
+                    delivery,
                     idempotent: false
                 };
             }

package/dist/service/skill-directory-service.d.ts

@@ -4,6 +4,7 @@ export interface LocalSkillInspection {
     readonly name: string;
     readonly description: string;
     readonly localStatus: LocalSkillStatus;
+    readonly skillFilePath: string;
     readonly install?: SkillInstallMetadata;
 }
 export interface LocalSkillTargetInspection {

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

@@ -53,13 +53,25 @@ async function scanRoot(root, source) {
         const itemPath = path.join(root, entry.name);
         const stat = await lstat(itemPath);
         if (stat.isSymbolicLink() || (!stat.isDirectory() && process.platform === 'win32')) {
-            results.push({ name: entry.name, description: '', localStatus: 'INVALID_LINK', source });
+            results.push({
+                name: entry.name,
+                description: '',
+                localStatus: 'INVALID_LINK',
+                skillFilePath: path.join(itemPath, 'SKILL.md'),
+                source
+            });
             continue;
         }
         if (!stat.isDirectory())
             continue;
         if (!SKILL_NAME.test(entry.name) || WINDOWS_DEVICE_NAME.test(entry.name)) {
-            results.push({ name: entry.name, description: '', localStatus: 'INVALID', source });
+            results.push({
+                name: entry.name,
+                description: '',
+                localStatus: 'INVALID',
+                skillFilePath: path.join(itemPath, 'SKILL.md'),
+                source
+            });
             continue;
         }
         results.push({ ...(await inspectSkill(itemPath, entry.name)), source });
@@ -72,17 +84,28 @@ async function inspectSkill(directory, directoryName) {
         if (frontmatter.name !== directoryName ||
             !SKILL_NAME.test(frontmatter.name) ||
             WINDOWS_DEVICE_NAME.test(frontmatter.name))
-            return { name: directoryName, description: frontmatter.description, localStatus: 'INVALID' };
+            return {
+                name: directoryName,
+                description: frontmatter.description,
+                localStatus: 'INVALID',
+                skillFilePath: path.join(directory, 'SKILL.md')
+            };
         const install = await readInstallMetadata(path.join(directory, '.mar-skill-install.json'));
         return {
             name: directoryName,
             description: frontmatter.description,
             localStatus: install === undefined ? 'UNKNOWN_VERSION' : 'VALID',
+            skillFilePath: path.join(directory, 'SKILL.md'),
             ...(install === undefined ? {} : { install })
         };
     }
     catch {
-        return { name: directoryName, description: '', localStatus: 'INVALID' };
+        return {
+            name: directoryName,
+            description: '',
+            localStatus: 'INVALID',
+            skillFilePath: path.join(directory, 'SKILL.md')
+        };
     }
 }
 async function readInstallMetadata(file) {
@@ -149,7 +172,12 @@ function mergeWorkspaceCopies(agents, claude) {
             };
         if (copies.agents.localStatus !== copies.claude.localStatus ||
             JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
-            return { name, description: copies.agents.description, localStatus: 'PARTIAL' };
+            return {
+                name,
+                description: copies.agents.description,
+                localStatus: 'PARTIAL',
+                skillFilePath: copies.agents.skillFilePath
+            };
         return withoutSource(copies.agents);
     });
 }
@@ -167,7 +195,12 @@ function mergeNodeCompatibilityRoots(agents, claude) {
         if (copies.agents.description !== copies.claude.description ||
             copies.agents.localStatus !== copies.claude.localStatus ||
             JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
-            return { name, description: copies.agents.description, localStatus: 'PARTIAL' };
+            return {
+                name,
+                description: copies.agents.description,
+                localStatus: 'PARTIAL',
+                skillFilePath: copies.agents.skillFilePath
+            };
         return withoutSource(copies.agents);
     });
 }
@@ -176,6 +209,7 @@ function withoutSource(entry) {
         name: entry.name,
         description: entry.description,
         localStatus: entry.localStatus,
+        skillFilePath: entry.skillFilePath,
         ...(entry.install === undefined ? {} : { install: entry.install })
     };
 }

package/dist/service/workspace-domain-state.d.ts

@@ -5,6 +5,8 @@ export interface WorkspaceWatch {
     readonly workspaceId: string;
     readonly watchId: string;
     readonly sessionHash: string;
+    readonly workbenchConnectionId: string;
+    readonly nodeGeneration: string;
     expiresAt: number;
     readonly topics: {
         readonly sessions: boolean;
@@ -56,6 +58,7 @@ export declare class WorkspaceDomainState {
     readonly fileIndexes: Map<string, WorkspaceFileIndex>;
     readonly watches: Map<string, Map<string, WorkspaceWatch>>;
     readonly watchRevisions: Map<string, number>;
+    watchSnapshotSequence: number;
     readonly sessionWatchTimers: Map<string, NodeJS.Timeout>;
     readonly sessionWatchSignatures: Map<string, string>;
     readonly sessionWatchReads: Map<string, Promise<void>>;

package/dist/service/workspace-domain-state.js

@@ -7,6 +7,7 @@ export class WorkspaceDomainState {
     fileIndexes = new Map();
     watches = new Map();
     watchRevisions = new Map();
+    watchSnapshotSequence = 0;
     sessionWatchTimers = new Map();
     sessionWatchSignatures = new Map();
     sessionWatchReads = new Map();

package/dist/service/workspace-file-service.d.ts

@@ -9,6 +9,7 @@ export declare class WorkspaceFileService {
     constructor(state: WorkspaceDomainState, allowedRoots: () => readonly string[], onInvalidated: (workspaceId: string) => void);
     list(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
     read(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
+    readContent(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
     search(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
     mutate(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
     private serializeMutation;

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

@@ -1,5 +1,5 @@
 import { isAbsolute } from 'node:path';
-import { listWorkspaceFiles, mutateWorkspaceFile, readAllowedTextFile, readWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
+import { listWorkspaceFiles, mutateWorkspaceFile, readWorkspaceFileContentRange, readAllowedTextFile, readWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 const INDEX_CACHE_LIMIT = 8;
 export class WorkspaceFileService {
     state;
@@ -36,6 +36,19 @@ export class WorkspaceFileService {
             ? readAllowedTextFile(input.path, this.allowedRoots(), offset, limit)
             : readWorkspaceTextFile(workspace.path, input.path, offset, limit);
     }
+    async readContent(workspace, input) {
+        if (typeof input.path !== 'string' ||
+            (input.offset !== undefined &&
+                (!Number.isInteger(input.offset) || input.offset < 0)) ||
+            (input.limit !== undefined &&
+                (!Number.isInteger(input.limit) ||
+                    input.limit < 1 ||
+                    input.limit > 512 * 1024)))
+            throw new Error('FILE_RANGE_INVALID');
+        if (isAbsolute(input.path))
+            throw new Error('FILE_PATH_ESCAPE');
+        return readWorkspaceFileContentRange(workspace.path, input.path, typeof input.offset === 'number' ? input.offset : 0, typeof input.limit === 'number' ? input.limit : 512 * 1024);
+    }
     async search(workspace, input) {
         if (typeof input.query !== 'string' ||
             (input.cursor !== undefined && typeof input.cursor !== 'string') ||

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -18,6 +18,17 @@ export interface QueuedRunStart<TAttachment = unknown> {
     readonly collaborationMode: 'default' | 'plan';
     readonly serviceTier?: 'fast';
     readonly secretEnvironment: Readonly<Record<string, string>>;
+    readonly personalInstructions?: string;
+}
+interface EnqueuedRunDisposition {
+    readonly runId: string;
+    readonly intent: 'SEND' | 'QUEUE' | 'REPLACE_CURRENT';
+    readonly queueBefore: {
+        readonly paused: boolean;
+        readonly runIds: readonly string[];
+    };
+    readonly leaseWasActive: boolean;
+    readonly activeRunId?: string;
 }
 export interface WorkspaceQueueWorkbenchServiceOptions {
     readonly runtime: NodeRuntimeState;
@@ -35,6 +46,7 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
 export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     private readonly options;
     private readonly starts;
+    private readonly scheduledSessions;
     constructor(options: WorkspaceQueueWorkbenchServiceOptions);
     enqueue(start: QueuedRunStart<TAttachment>, message: {
         readonly runId: string;
@@ -50,7 +62,10 @@ export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     pending(runId: string): QueuedRunStart<TAttachment> | undefined;
     remove(runId: string): void;
     clear(): void;
+    publish(sessionId: string): void;
     migrateSession(previousId: string, nextId: string): void;
+    cancelQueued(runId: string): void;
+    pauseForInterrupt(sessionId: string): void;
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private get;
     private pauseOrResume;
@@ -62,7 +77,9 @@ export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     private requireRun;
     replace(queuedRunId: string, activeRunId: string, prioritize?: boolean): void;
     schedule(sessionId: string): void;
+    settleEnqueue(input: EnqueuedRunDisposition): 'STARTED' | 'QUEUED' | 'RESTARTING';
     dispatch(sessionId: string): Promise<void>;
     present(workspaceId: string, sessionId: string): unknown;
     private updatePending;
 }
+export {};

package/dist/service/workspace-queue-workbench-service.js

@@ -5,6 +5,7 @@ import { safeErrorCode } from '../util/safe-error.js';
 export class WorkspaceQueueWorkbenchService {
     options;
     starts = new Map();
+    scheduledSessions = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -24,12 +25,44 @@ export class WorkspaceQueueWorkbenchService {
     }
     clear() {
         this.starts.clear();
+        for (const timer of this.scheduledSessions.values())
+            clearTimeout(timer);
+        this.scheduledSessions.clear();
+    }
+    publish(sessionId) {
+        const session = this.options.runtime.getAgentSession(sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        this.options.emit(session.workspaceId, session.id);
     }
     migrateSession(previousId, nextId) {
         for (const [runId, pending] of this.starts) {
             if (pending.sessionId === previousId)
                 this.starts.set(runId, { ...pending, sessionId: nextId, externalSessionId: nextId });
         }
+        const timer = this.scheduledSessions.get(previousId);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.scheduledSessions.delete(previousId);
+            this.schedule(nextId);
+        }
+    }
+    cancelQueued(runId) {
+        const run = this.requireRun(runId);
+        if (!this.options.runtime.isQueuedRun(run.id))
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.options.runtime.deleteQueuedRun(run.id);
+        this.remove(run.id);
+        this.options.clearImages(run.id);
+        this.options.cleanupAttachments(run.id);
+        this.options.emit(run.workspaceId, run.sessionId);
+    }
+    pauseForInterrupt(sessionId) {
+        const session = this.options.runtime.getAgentSession(sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        this.options.runtime.pauseSessionQueue(session.id);
+        this.publish(session.id);
     }
     operations() {
         return {
@@ -82,11 +115,7 @@ export class WorkspaceQueueWorkbenchService {
         if (typeof input.runId !== 'string')
             throw new Error('QUEUE_INVALID');
         const run = this.requireRun(input.runId);
-        this.options.runtime.deleteQueuedRun(run.id);
-        this.remove(run.id);
-        this.options.clearImages(run.id);
-        this.options.cleanupAttachments(run.id);
-        this.options.emit(run.workspaceId, run.sessionId);
+        this.cancelQueued(run.id);
         return { queue: this.present(run.workspaceId, run.sessionId) };
     }
     execute(input) {
@@ -105,7 +134,6 @@ export class WorkspaceQueueWorkbenchService {
             .listRunsForSession(session.id)
             .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
         this.options.runtime.prioritizeQueuedRun(queued.id);
-        this.options.emit(queued.workspaceId, session.id);
         if (active !== undefined) {
             this.replace(queued.id, active.id, false);
             return { run: queued, delivery: 'RESTARTING' };
@@ -137,17 +165,46 @@ export class WorkspaceQueueWorkbenchService {
             throw new Error('QUEUE_ITEM_INVALID');
         if (prioritize)
             this.options.runtime.prioritizeQueuedRun(queued.id);
+        this.options.emit(queued.workspaceId, queued.sessionId);
         this.options.markInterrupted(active.id);
         this.options.runtime.transitionRun(active.id, 'CANCELLING');
         this.options.control('run.interrupt', { runId: active.id });
     }
     schedule(sessionId) {
+        if (this.scheduledSessions.has(sessionId))
+            return;
         const timer = setTimeout(() => {
+            this.scheduledSessions.delete(sessionId);
             if (!this.options.stopped())
                 void this.dispatch(sessionId);
         }, 0);
+        this.scheduledSessions.set(sessionId, timer);
         timer.unref();
     }
+    settleEnqueue(input) {
+        const run = this.requireRun(input.runId);
+        const session = this.options.runtime.getAgentSession(run.sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (input.queueBefore.paused && input.activeRunId === undefined && input.intent !== 'QUEUE')
+            this.options.runtime.prioritizeQueuedRun(run.id);
+        if (!input.queueBefore.paused || input.intent !== 'QUEUE')
+            this.options.runtime.resumeSessionQueue(session.id);
+        if (input.activeRunId !== undefined) {
+            this.replace(run.id, input.activeRunId);
+            return 'RESTARTING';
+        }
+        const leaseIsActive = input.leaseWasActive && this.options.runtime.hasActiveSessionLease(session.id);
+        const dispatchNow = !leaseIsActive && !(input.queueBefore.paused && input.intent === 'QUEUE');
+        const startsNow = dispatchNow &&
+            (input.queueBefore.runIds.length === 0 ||
+                (input.queueBefore.paused && input.intent !== 'QUEUE'));
+        if (dispatchNow)
+            this.schedule(session.id);
+        else
+            this.options.emit(session.workspaceId, session.id);
+        return startsNow ? 'STARTED' : 'QUEUED';
+    }
     async dispatch(sessionId) {
         const run = this.options.runtime.claimNextQueuedRun(sessionId);
         if (run === undefined)
@@ -186,6 +243,9 @@ export class WorkspaceQueueWorkbenchService {
                 collaborationMode: pending.collaborationMode,
                 ...(pending.serviceTier === undefined ? {} : { serviceTier: pending.serviceTier }),
                 secretEnvironment: pending.secretEnvironment,
+                ...(pending.personalInstructions === undefined
+                    ? {}
+                    : { personalInstructions: pending.personalInstructions }),
                 mcpInstallations: this.options.mcps(pending.workspaceId)
             });
         }

package/dist/service/workspace-watch-service.d.ts

@@ -7,12 +7,17 @@ export declare class WorkspaceWatchService {
     parseTopics(input: Record<string, unknown>): WorkspaceWatch['topics'];
     key(input: Record<string, unknown>): string;
     sessionHash(input: Record<string, unknown>): string;
-    create(workspaceId: string, watchId: string, sessionHash: string, topics: WorkspaceWatch['topics']): WorkspaceWatch;
-    renew(workspaceId: string, key: string): WorkspaceWatch | undefined;
+    connectionId(input: Record<string, unknown>): string;
+    create(workspaceId: string, watchId: string, sessionHash: string, workbenchConnectionId: string, nodeGeneration: string, topics: WorkspaceWatch['topics']): WorkspaceWatch;
+    renew(workspaceId: string, key: string, watchId?: string): WorkspaceWatch | undefined;
+    matches(workspaceId: string, key: string, watchId: string): boolean;
+    existing(workspaceId: string, key: string): WorkspaceWatch | undefined;
     remove(workspaceId: string, key: string): void;
     clear(workspaceId: string): void;
     clearAll(): void;
     nextRevision(workspaceId: string): number;
+    nextSnapshotSequence(): number;
     topicActive(workspaceId: string, topic: 'files' | 'changes' | 'sessions'): boolean;
+    activeWatches(workspaceId: string): readonly WorkspaceWatch[];
     private expiryTimer;
 }

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

@@ -36,20 +36,29 @@ export class WorkspaceWatchService {
         return { sessions, changes, files };
     }
     key(input) {
-        return `${this.sessionHash(input)}:${input.watchId}`;
+        return `${this.sessionHash(input)}:${this.connectionId(input)}`;
     }
     sessionHash(input) {
         return typeof input.__workspaceWatchSessionHash === 'string'
             ? input.__workspaceWatchSessionHash
             : 'local-test';
     }
-    create(workspaceId, watchId, sessionHash, topics) {
-        const key = `${sessionHash}:${watchId}`;
-        this.remove(workspaceId, key);
+    connectionId(input) {
+        if (typeof input.workbenchConnectionId !== 'string')
+            throw new Error('WORKSPACE_WATCH_INVALID');
+        return input.workbenchConnectionId;
+    }
+    create(workspaceId, watchId, sessionHash, workbenchConnectionId, nodeGeneration, topics) {
+        const key = `${sessionHash}:${workbenchConnectionId}`;
+        for (const [activeWorkspaceId, watches] of this.state.watches)
+            if (watches.has(key))
+                this.remove(activeWorkspaceId, key);
         const watch = {
             workspaceId,
             watchId,
             sessionHash,
+            workbenchConnectionId,
+            nodeGeneration,
             expiresAt: Date.now() + WATCH_TTL_MS,
             topics,
             timer: undefined
@@ -62,9 +71,11 @@ export class WorkspaceWatchService {
             this.onSessionWatchRequired(workspaceId);
         return watch;
     }
-    renew(workspaceId, key) {
+    renew(workspaceId, key, watchId) {
         const watch = this.state.watches.get(workspaceId)?.get(key);
-        if (watch === undefined || watch.expiresAt <= Date.now()) {
+        if (watch === undefined || watch.watchId !== watchId)
+            return undefined;
+        if (watch.expiresAt <= Date.now()) {
             this.remove(workspaceId, key);
             return undefined;
         }
@@ -73,6 +84,14 @@ export class WorkspaceWatchService {
         watch.timer = this.expiryTimer(workspaceId, key);
         return watch;
     }
+    matches(workspaceId, key, watchId) {
+        const watch = this.state.watches.get(workspaceId)?.get(key);
+        return watch !== undefined && watch.watchId === watchId && watch.expiresAt > Date.now();
+    }
+    existing(workspaceId, key) {
+        const watch = this.state.watches.get(workspaceId)?.get(key);
+        return watch !== undefined && watch.expiresAt > Date.now() ? watch : undefined;
+    }
     remove(workspaceId, key) {
         const watches = this.state.watches.get(workspaceId);
         const watch = watches?.get(key);
@@ -106,9 +125,16 @@ export class WorkspaceWatchService {
         this.state.watchRevisions.set(workspaceId, revision);
         return revision;
     }
+    nextSnapshotSequence() {
+        this.state.watchSnapshotSequence += 1;
+        return this.state.watchSnapshotSequence;
+    }
     topicActive(workspaceId, topic) {
         return [...(this.state.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
     }
+    activeWatches(workspaceId) {
+        return [...(this.state.watches.get(workspaceId)?.values() ?? [])].filter((watch) => watch.expiresAt > Date.now());
+    }
     expiryTimer(workspaceId, key) {
         const timer = setTimeout(() => this.remove(workspaceId, key), WATCH_TTL_MS);
         timer.unref();

package/dist/service/workspace-workbench-service.d.ts

@@ -12,14 +12,26 @@ export interface WorkspaceWorkbenchServiceOptions {
     readonly changes: WorkspaceChangeService;
     readonly listSessions: (workspaceId: string) => Promise<unknown>;
     readonly invalidate: (workspaceId: string) => void;
+    readonly nodeId: () => string;
+    readonly nodeGeneration: () => string;
+    readonly emitWatchEvent: (payload: unknown) => void;
 }
 export declare class WorkspaceWorkbenchService {
     private readonly options;
     private readonly contentSearch;
+    private readonly topicRefreshes;
+    private readonly dirtyTopics;
     constructor(options: WorkspaceWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
+    refreshTopic(workspaceId: string, topic: 'sessions' | 'files' | 'changes'): Promise<void>;
+    private emitTopicFailure;
+    private performTopicRefresh;
     private watch;
     private unwatch;
+    private accepted;
+    private createInitialSnapshots;
+    private emitSnapshot;
+    private deliverSnapshot;
     private listFiles;
     private readFile;
     private searchFiles;
@@ -31,6 +43,7 @@ export declare class WorkspaceWorkbenchService {
     private completeUpload;
     private cancelUpload;
     private currentChanges;
+    private readFileContent;
     private changeDiff;
     private restoreChange;
     private gitRepository;
@@ -39,6 +52,7 @@ export declare class WorkspaceWorkbenchService {
     private gitHistory;
     private gitCommitFiles;
     private gitCommitFileDiff;
+    private gitCommitFileContent;
     private diff;
     private gitWorkspace;
 }