@myagentroam/node 0.9.3 → 0.9.5

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

@@ -1,7 +1,10 @@
+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();
     constructor(options) {
         this.options = options;
     }
@@ -19,20 +22,19 @@ export class SessionMessageService {
             typeof input.content !== 'string' ||
             input.content.length === 0)
             throw new Error('MESSAGE_INVALID');
+        const clientMessageId = input.clientMessageId;
+        const content = input.content;
         const inlineAttachments = parseMessageAttachments(input.attachments);
         const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
         const attachmentIds = parseComposerAttachmentIds(input.attachmentIds);
         if (inlineAttachments.length > 0 && attachmentIds.length > 0)
             throw new Error('MESSAGE_ATTACHMENTS_INVALID');
-        const session = this.options.runtime.setTemporaryTitleIfMissing((await this.options.resolve(input.sessionId)).id, sessionTitleFromFirstMessage(input.content));
-        this.options.emitSession(session);
-        const intent = input.deliveryIntent;
-        if (intent !== undefined &&
-            intent !== 'SEND' &&
-            intent !== 'QUEUE' &&
-            intent !== 'REPLACE_CURRENT')
+        const session = await this.options.resolve(input.sessionId);
+        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, input.clientMessageId);
+        const existing = this.options.runtime.findMessageRun(session.id, clientMessageId);
         if (existing !== undefined)
             return {
                 session: this.options.present(session),
@@ -40,84 +42,103 @@ export class SessionMessageService {
                 delivery: this.options.runtime.isQueuedRun(existing.id) ? 'QUEUED' : 'STARTED',
                 idempotent: true
             };
-        const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
-        const attachments = attachmentIds.length === 0
-            ? inlineAttachments
-            : uploaded.map((attachment) => attachment.attachment);
-        const imageAttachments = attachments.filter(isImageAttachment);
-        const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
-        const active = this.options.runtime
-            .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 created = this.options.runtime.createMessageRun({
-            sessionId: session.id,
-            clientMessageId: input.clientMessageId,
-            content: input.content,
-            ...(attachments.length === 0 ? {} : { attachments })
-        });
-        if (!created.created)
-            return {
-                session: this.options.present(session),
-                run: created.run,
-                delivery: this.options.runtime.isQueuedRun(created.run.id) ? 'QUEUED' : 'STARTED',
-                idempotent: true
-            };
-        this.options.attachments.cache(created.run.id, imageAttachments);
-        let attachmentPaths;
+        const pendingKey = `${session.id}\u0000${clientMessageId}`;
+        const pending = this.pendingMessages.get(pendingKey);
+        if (pending !== undefined)
+            return pending;
+        const operation = (async () => {
+            const runId = randomUUID();
+            let enqueued = false;
+            try {
+                const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
+                const attachments = attachmentIds.length === 0
+                    ? inlineAttachments
+                    : uploaded.map((attachment) => attachment.attachment);
+                const imageAttachments = attachments.filter(isImageAttachment);
+                const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
+                const attachmentPaths = await this.persistAttachments(session, runId, attachments);
+                const runnerInput = withNonImageAttachmentPrompt(content, attachmentPaths);
+                const planActive = this.options.commands
+                    .list(session.id)
+                    .some((state) => state.commandId === 'plan');
+                const runner = this.options.runners.require(session.runner);
+                const active = this.options.runtime
+                    .listRunsForSession(session.id)
+                    .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
+                const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
+                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,
+                    workspaceId: session.workspaceId,
+                    runner: session.runner,
+                    input: runner.prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
+                    attachments: runnerImageAttachments,
+                    attachmentPaths,
+                    cwd: session.cwd,
+                    externalSessionId: session.externalSessionId,
+                    model: session.model,
+                    effort: session.effort,
+                    access: session.access,
+                    collaborationMode: planActive ? 'plan' : 'default',
+                    secretEnvironment,
+                    ...(personalInstructions === undefined ? {} : { personalInstructions }),
+                    ...(runner.serviceTier() === 'fast' ? { serviceTier: 'fast' } : {})
+                }, {
+                    runId,
+                    sessionId: session.id,
+                    clientMessageId,
+                    content: runnerInput,
+                    ...(Number.isSafeInteger(input.__requestUserId)
+                        ? { initiatedByUserId: input.__requestUserId }
+                        : {}),
+                    ...(attachments.length === 0 ? {} : { attachments })
+                });
+                enqueued = created.created;
+                if (!created.created) {
+                    this.options.attachments.cleanup(runId);
+                    return {
+                        session: this.options.present(session),
+                        run: created.run,
+                        delivery: this.options.runtime.isQueuedRun(created.run.id) ? 'QUEUED' : 'STARTED',
+                        idempotent: true
+                    };
+                }
+                const acceptedSession = this.options.runtime.setTemporaryTitleIfMissing(session.id, sessionTitleFromFirstMessage(content));
+                this.options.emitSession(acceptedSession);
+                this.options.attachments.cache(created.run.id, imageAttachments);
+                void this.options.uploads.consume(attachmentIds).catch(() => undefined);
+                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,
+                    idempotent: false
+                };
+            }
+            catch (error) {
+                if (!enqueued) {
+                    this.options.attachments.clear(runId);
+                    this.options.attachments.cleanup(runId);
+                }
+                throw error;
+            }
+        })();
+        this.pendingMessages.set(pendingKey, operation);
         try {
-            attachmentPaths = await this.persistAttachments(session, created.run.id, attachments);
-            await this.options.uploads.consume(attachmentIds);
+            return await operation;
         }
-        catch (error) {
-            this.options.runtime.deleteQueuedRun(created.run.id);
-            this.options.attachments.clear(created.run.id);
-            this.options.attachments.cleanup(created.run.id);
-            throw error;
+        finally {
+            if (this.pendingMessages.get(pendingKey) === operation)
+                this.pendingMessages.delete(pendingKey);
         }
-        const runnerInput = withNonImageAttachmentPrompt(input.content, attachmentPaths);
-        this.options.runtime.updateQueuedMessage(created.run.id, runnerInput);
-        const planActive = this.options.commands
-            .list(session.id)
-            .some((state) => state.commandId === 'plan');
-        this.options.queue.remember({
-            runId: created.run.id,
-            sessionId: created.run.sessionId,
-            workspaceId: created.run.workspaceId,
-            runner: created.run.runner,
-            input: this.options.runners
-                .require(created.run.runner)
-                .prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
-            attachments: runnerImageAttachments,
-            attachmentPaths,
-            cwd: session.cwd,
-            externalSessionId: session.externalSessionId,
-            model: session.model,
-            effort: session.effort,
-            access: session.access,
-            collaborationMode: planActive ? 'plan' : 'default',
-            secretEnvironment,
-            ...(this.options.runners.require(created.run.runner).serviceTier() === 'fast'
-                ? { serviceTier: 'fast' }
-                : {})
-        });
-        if (queueWasPaused && active === undefined && intent !== 'QUEUE')
-            this.options.runtime.prioritizeQueuedRun(created.run.id);
-        if (!queueWasPaused || intent !== 'QUEUE')
-            this.options.runtime.resumeSessionQueue(session.id);
-        this.options.emitQueue(session.workspaceId, session.id);
-        if (replaceCurrentRun !== undefined)
-            this.options.queue.replace(created.run.id, replaceCurrentRun.id);
-        else if (intent !== 'QUEUE' || !queuedBeforeCreate)
-            this.options.queue.schedule(session.id);
-        return {
-            session: this.options.present(session),
-            run: created.run,
-            delivery: replaceCurrentRun !== undefined ? 'RESTARTING' : queuedBeforeCreate ? 'QUEUED' : 'STARTED',
-            idempotent: false
-        };
     }
     async persistAttachments(session, runId, attachments) {
         return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));

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-change-service.js

@@ -60,7 +60,7 @@ export class WorkspaceChangeService {
                 additions: null,
                 deletions: null,
                 binary: false,
-                diffAvailable: change.state !== 'UNTRACKED'
+                diffAvailable: true
             });
             const value = {
                 branch: root.branch,

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

@@ -1,7 +1,7 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { RunnerName } from '@myagentroam/protocol';
-import type { NodeMcpInstallation } from '../database.js';
+import type { NodeAgentRun, NodeMcpInstallation, NodeMessageAttachmentInput } from '../database.js';
 export interface QueuedRunStart<TAttachment = unknown> {
     readonly runId: string;
     readonly sessionId: string;
@@ -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,12 +46,26 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
 export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     private readonly options;
     private readonly starts;
+    private readonly scheduledSessions;
     constructor(options: WorkspaceQueueWorkbenchServiceOptions);
-    remember(start: QueuedRunStart<TAttachment>): void;
+    enqueue(start: QueuedRunStart<TAttachment>, message: {
+        readonly runId: string;
+        readonly sessionId: string;
+        readonly clientMessageId: string;
+        readonly content: string;
+        readonly initiatedByUserId?: number;
+        readonly attachments?: readonly NodeMessageAttachmentInput[];
+    }): {
+        readonly run: NodeAgentRun;
+        readonly created: boolean;
+    };
     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;
@@ -52,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,11 +5,17 @@ import { safeErrorCode } from '../util/safe-error.js';
 export class WorkspaceQueueWorkbenchService {
     options;
     starts = new Map();
+    scheduledSessions = new Map();
     constructor(options) {
         this.options = options;
     }
-    remember(start) {
-        this.starts.set(start.runId, start);
+    enqueue(start, message) {
+        if (message.runId !== start.runId || message.sessionId !== start.sessionId)
+            throw new Error('QUEUE_RUN_MISMATCH');
+        const created = this.options.runtime.createMessageRun(message);
+        if (created.created)
+            this.starts.set(start.runId, start);
+        return created;
     }
     pending(runId) {
         return this.starts.get(runId);
@@ -19,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 {
@@ -77,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) {
@@ -100,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' };
@@ -132,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)
@@ -181,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;
 }