@myagentroam/node 0.10.62 → 0.10.64

package/dist/connector.js

@@ -898,6 +898,9 @@ export class NodeConnector {
             emitSession: (session) => this.publishWorkbenchEvent('session', {
                 session: this.sessionPresentationService.present(session)
             }),
+            invalidateWorkspaceSessions: (workspaceId) => {
+                void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions');
+            },
             execute: (operation, data) => this.modelUsage.withGrant(isPlainRecord(data) ? data.__usageGrant : undefined, () => this.executeNodeOperation(operation, data)),
             interceptedSessionId: (clientMessageId) => this.fakeRunner === undefined ? undefined : `fake:${clientMessageId}`
         });
@@ -998,7 +1001,6 @@ export class NodeConnector {
             discoveryPending: (workspaceId) => this.workspaceSessionService.discoveryPending(workspaceId),
             discoverWorkspace: (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId),
             present: (session) => this.sessionPresentationService.present(session),
-            projectionForNative: (session) => this.nativeSessionProjectionService.projectionForNative(session),
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
             forget: (session, nativeIds) => {
                 this.nativeSessionProjectionService.forget(session, nativeIds);

package/dist/database.js

@@ -363,13 +363,14 @@ export class NodeDatabase {
         if (current === undefined || current['pin_order'] === null)
             throw new Error('SESSION_NOT_PINNED');
         const order = numberValue(current, 'pin_order');
+        const workspaceId = stringValue(current, 'workspace_id');
         const adjacent = this.raw
             .prepare(direction === 'up'
             ? 'SELECT id, pin_order FROM agent_sessions WHERE workspace_id = ? AND pin_order < ? ORDER BY pin_order DESC LIMIT 1'
             : 'SELECT id, pin_order FROM agent_sessions WHERE workspace_id = ? AND pin_order > ? ORDER BY pin_order ASC LIMIT 1')
-            .get(stringValue(current, 'workspace_id'), order);
+            .get(workspaceId, order);
         if (adjacent === undefined)
-            return;
+            return workspaceId;
         this.raw.exec('BEGIN IMMEDIATE');
         try {
             this.raw
@@ -384,6 +385,7 @@ export class NodeDatabase {
             this.raw.exec('ROLLBACK');
             throw error;
         }
+        return workspaceId;
     }
     deleteSessionRecord(sessionId) {
         this.raw.exec('BEGIN IMMEDIATE');

package/dist/runtime-state.js

@@ -157,15 +157,36 @@ export class NodeRuntimeState {
         this.emitRunChanged(run, session);
         return run;
     }
+    getAgentSessionById(id) {
+        return this.sessions.get(this.resolvePromotedSessionId(id));
+    }
     getAgentSession(id) {
-        return (this.sessions.get(this.resolvePromotedSessionId(id)) ??
+        return (this.getAgentSessionById(id) ??
             [...this.sessions.values()].find((value) => value.externalSessionId === id));
     }
     listAgentSessions() {
         return [...this.sessions.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt);
     }
-    findAgentSessionByExternalSession(runner, externalSessionId) {
-        return [...this.sessions.values()].find((value) => value.runner === runner && value.externalSessionId === externalSessionId);
+    findAgentSessionByExternalSession(runner, externalSessionId, workspaceId) {
+        return [...this.sessions.values()].find((value) => value.runner === runner &&
+            value.externalSessionId === externalSessionId &&
+            (workspaceId === undefined || value.workspaceId === workspaceId));
+    }
+    /** Request-local identity lookups; callers must consume them synchronously. */
+    createSessionLookup() {
+        const byId = new Map(this.sessions);
+        const byNative = new Map();
+        for (const session of byId.values()) {
+            if (session.externalSessionId === null)
+                continue;
+            const key = JSON.stringify([session.runner, session.workspaceId, session.externalSessionId]);
+            if (!byNative.has(key))
+                byNative.set(key, session);
+        }
+        return {
+            getAgentSessionById: (id) => byId.get(this.resolvePromotedSessionId(id)),
+            findAgentSessionByExternalSession: (runner, externalId, workspaceId) => byNative.get(JSON.stringify([runner, workspaceId, externalId]))
+        };
     }
     updateAgentSessionConfiguration(input) {
         return this.replaceSession(input.sessionId, {
@@ -826,8 +847,13 @@ export class NodeRuntimeState {
         };
     }
     conversationTurnForRun(runId) {
+        const canonicalRunId = this.canonicalRunId(runId);
+        const run = this.runs.get(canonicalRunId);
+        if (run !== undefined)
+            return (this.turns.get(run.sessionId) ?? []).findLast((turn) => turn.runId === canonicalRunId);
+        // Terminal Run cleanup may retain Turns after removing the Run.
         for (const turns of this.turns.values()) {
-            const turn = turns.findLast((candidate) => candidate.runId === this.canonicalRunId(runId));
+            const turn = turns.findLast((candidate) => candidate.runId === canonicalRunId);
             if (turn !== undefined)
                 return turn;
         }

package/dist/service/conversation-hosting-lifecycle-service.js

@@ -59,8 +59,12 @@ export class ConversationHostingLifecycleService {
             await resources.maintenance.dispose();
         }
         finally {
-            resources.service.dispose();
-            await resources.runtime.dispose().catch(() => undefined);
+            try {
+                await resources.service.dispose();
+            }
+            finally {
+                await resources.runtime.dispose().catch(() => undefined);
+            }
         }
     }
     async rebuild() {
@@ -159,9 +163,29 @@ export class ConversationHostingLifecycleService {
                     };
                 }
                 catch (error) {
-                    await maintenanceService?.dispose();
-                    hostedService?.dispose();
-                    await runtime?.dispose().catch(() => undefined);
+                    try {
+                        await maintenanceService?.dispose();
+                    }
+                    catch (cleanupError) {
+                        nodeLog('conversation.hosting.cleanup.failed', {
+                            nodeId: config.nodeId,
+                            code: safeErrorCode(cleanupError, 'CONVERSATION_HOSTING_CLEANUP_FAILED')
+                        });
+                    }
+                    finally {
+                        try {
+                            await hostedService?.dispose();
+                        }
+                        catch (cleanupError) {
+                            nodeLog('conversation.hosting.cleanup.failed', {
+                                nodeId: config.nodeId,
+                                code: safeErrorCode(cleanupError, 'CONVERSATION_HOSTING_CLEANUP_FAILED')
+                            });
+                        }
+                        finally {
+                            await runtime?.dispose().catch(() => undefined);
+                        }
+                    }
                     if (this.closed)
                         return;
                     this.failureCode = safeErrorCode(error, 'CONVERSATION_HOSTING_RECOVERY_FAILED');

package/dist/service/hosted-conversation-node-service.js

@@ -45,6 +45,8 @@ export class HostedConversationNodeService {
     pendingUploadCreates = new Map();
     uploadNameReservations = new Map();
     fileDeletes = new Set();
+    fileWrites = new Map();
+    closing;
     watchLeases = new Map();
     cleanupLocks = new Set();
     historyMutations = new Map();
@@ -76,13 +78,13 @@ export class HostedConversationNodeService {
             'conversation.hosted.tool-resource.read': (raw) => this.readToolResource(raw),
             'conversation.hosted.files.list': (raw) => this.listFiles(raw),
             'conversation.hosted.file.read': (raw) => this.readFile(raw),
-            'conversation.hosted.file.delete': (raw) => this.deleteFile(raw),
+            'conversation.hosted.file.delete': (raw) => this.fileWrite(raw, hostedConversationFileDeleteInputSchema, () => this.deleteFile(raw)),
             'conversation.hosted.files.upload.preflight': (raw) => this.preflightUpload(raw),
-            'conversation.hosted.files.upload.create': (raw) => this.createUpload(raw),
-            'conversation.hosted.files.upload.chunk': (raw) => this.writeUploadChunk(raw),
+            'conversation.hosted.files.upload.create': (raw) => this.fileWrite(raw, hostedConversationUploadCreateInputSchema, () => this.createUpload(raw)),
+            'conversation.hosted.files.upload.chunk': (raw) => this.fileWrite(raw, hostedConversationUploadChunkInputSchema, () => this.writeUploadChunk(raw)),
             'conversation.hosted.files.upload.status': (raw) => this.uploadStatus(raw),
-            'conversation.hosted.files.upload.complete': (raw) => this.completeUpload(raw),
-            'conversation.hosted.files.upload.cancel': (raw) => this.cancelUpload(raw),
+            'conversation.hosted.files.upload.complete': (raw) => this.fileWrite(raw, hostedConversationUploadControlInputSchema, () => this.completeUpload(raw)),
+            'conversation.hosted.files.upload.cancel': (raw) => this.fileWrite(raw, hostedConversationUploadControlInputSchema, () => this.cancelUpload(raw)),
             'conversation.hosted.delete': (raw) => this.delete(raw)
         };
     }
@@ -293,6 +295,8 @@ export class HostedConversationNodeService {
         });
     }
     async watch(raw) {
+        if (this.closing)
+            throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
         const payload = hostedRequest(raw);
         const input = hostedConversationWatchInputSchema.parse(payload.data);
         const conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
@@ -306,8 +310,10 @@ export class HostedConversationNodeService {
                 !this.sessionWatchSlots.owns(ownerKey, lease.slotToken) ||
                 lease.watchId !== input.watchId ||
                 lease.conversationId !== input.conversationId ||
-                lease.userId !== payload.userId ||
-                lease.expiresAt <= Date.now()) {
+                lease.userId !== payload.userId) {
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            }
+            if (lease.expiresAt <= Date.now()) {
                 this.removeWatchLease(ownerKey);
                 throw new Error('SESSION_WATCH_NOT_FOUND');
             }
@@ -376,6 +382,7 @@ export class HostedConversationNodeService {
             this.historyMutations.has(conversationId) ||
             this.activeRuns.has(conversationId) ||
             this.runSettlements.has(conversationId) ||
+            this.fileWrites.has(conversationId) ||
             [...this.watchLeases.values()].some((lease) => lease.conversationId === conversationId) ||
             [...this.uploads.values()].some((upload) => upload.conversationId === conversationId && upload.status === 'UPLOADING') ||
             [...this.pendingMessages.keys()].some((key) => key.startsWith(`${conversationId}\0`)));
@@ -399,6 +406,9 @@ export class HostedConversationNodeService {
             .catch(() => undefined);
     }
     dispose() {
+        if (this.closing)
+            return this.closing;
+        this.disablePrepared = true;
         for (const [conversationId, handle] of this.activeRuns) {
             const interruptionKey = runInterruptionKey(conversationId, handle.run.id);
             this.expectedInterruptions.add(interruptionKey);
@@ -407,6 +417,50 @@ export class HostedConversationNodeService {
         }
         for (const ownerKey of [...this.watchLeases.keys()])
             this.removeWatchLease(ownerKey);
+        this.closing = (async () => {
+            await Promise.all([...this.fileWrites.keys()].map((id) => this.waitForFileWrites(id)));
+            await Promise.allSettled([...this.uploads.values()].map(async (upload) => {
+                if (upload.status === 'UPLOADING') {
+                    upload.status = 'CANCELLED';
+                    await rm(upload.temporaryPath, { force: true });
+                }
+            }));
+            this.uploads.clear();
+            this.uploadsByRequest.clear();
+            this.uploadNameReservations.clear();
+        })();
+        return this.closing;
+    }
+    async fileWrite(raw, schema, operation) {
+        const payload = hostedRequest(raw);
+        const input = schema.parse(payload.data);
+        if (this.closing)
+            throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
+        this.requireWritableConversation(payload.userId, input.conversationId);
+        const writes = this.fileWrites.get(input.conversationId) ?? new Set();
+        if (input.uploadId !== undefined &&
+            [...writes].some((write) => write.uploadId === input.uploadId))
+            throw new Error('HOSTED_CONVERSATION_FILE_CONFLICT');
+        // Register before the operation can enter its first asynchronous preparation.
+        const write = {
+            ...(input.uploadId === undefined ? {} : { uploadId: input.uploadId }),
+            completion: Promise.resolve().then(operation)
+        };
+        writes.add(write);
+        this.fileWrites.set(input.conversationId, writes);
+        try {
+            return await write.completion;
+        }
+        finally {
+            writes.delete(write);
+            if (writes.size === 0)
+                this.fileWrites.delete(input.conversationId);
+        }
+    }
+    async waitForFileWrites(conversationId) {
+        const writes = this.fileWrites.get(conversationId);
+        if (writes)
+            await Promise.allSettled([...writes].map((write) => write.completion));
     }
     message(raw) {
         if (this.disablePrepared)
@@ -778,17 +832,6 @@ export class HostedConversationNodeService {
         let conversation;
         try {
             this.options.store.finishRunMessages(conversationId, run.id, completion.status, completion.completedAt);
-            this.publishHostedEvent(conversationId, {
-                conversationId,
-                kind: 'run',
-                run: {
-                    id: run.id,
-                    status: completion.status,
-                    startedAt: run.startedAt,
-                    completedAt: completion.completedAt
-                }
-            });
-            void this.refreshReadyWatchSnapshots(conversationId, run.id);
             try {
                 const files = await this.options.store.reconcileFiles(userId, conversationId);
                 this.publishHostedEvent(conversationId, {
@@ -809,6 +852,17 @@ export class HostedConversationNodeService {
                     }
                 });
             }
+            this.publishHostedEvent(conversationId, {
+                conversationId,
+                kind: 'run',
+                run: {
+                    id: run.id,
+                    status: completion.status,
+                    startedAt: run.startedAt,
+                    completedAt: completion.completedAt
+                }
+            });
+            void this.refreshReadyWatchSnapshots(conversationId, run.id);
             await this.options.store.advanceLastActivity(conversationId, completion.completedAt);
             await this.applyAutomaticTitle(conversationId, completion.title, completion.completedAt).catch(() => undefined);
             conversation = this.options.store.requireConversation(userId, conversationId);
@@ -1195,6 +1249,8 @@ export class HostedConversationNodeService {
         return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
     }
     async delete(raw) {
+        if (this.closing)
+            throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
         const payload = hostedRequest(raw);
         const input = hostedConversationIdInputSchema.parse(payload.data);
         const conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
@@ -1210,6 +1266,7 @@ export class HostedConversationNodeService {
                 if (!handle.cancel())
                     this.expectedInterruptions.delete(interruptionKey);
             }
+            await this.waitForFileWrites(conversation.id);
             await this.cancelConversationUploads(payload.userId, conversation.id);
             const paths = this.options.store.pathsForConversation(payload.userId, conversation.id);
             await this.options.runtime

package/dist/service/native-session-projection-service.js

@@ -254,31 +254,42 @@ export class NativeSessionProjectionService {
             ? undefined
             : [
                 'Similar Sessions (suggestions only; no action was redirected):',
-                ...candidates.map(({ id, title }) => id + ' ' + title.replace(/[\u0000-\u001f\u007f]/gu, ' ').slice(0, 160))
+                ...candidates.map(({ id, title }) => 
+                // eslint-disable-next-line no-control-regex -- Strip ASCII controls from user titles.
+                id + ' ' + title.replace(/[\u0000-\u001f\u007f]/gu, ' ').slice(0, 160))
             ].join('\n');
     }
     projectionForNative(native) {
+        return this.resolveNativeProjection(native, this.options.runtime, false);
+    }
+    projectionsForNative(native) {
+        const lookup = this.options.runtime.createSessionLookup();
+        return new Map(native.map((session) => [session, this.resolveNativeProjection(session, lookup, false)]));
+    }
+    managedForNative(native) {
+        return this.resolveNativeProjection(native, this.options.runtime, true);
+    }
+    resolveNativeProjection(native, lookup, managedOnly) {
         if (native.externalSessionId === null)
             return undefined;
-        const exact = this.options.runtime.findAgentSessionByExternalSession(native.runner, native.externalSessionId);
+        const exact = lookup.findAgentSessionByExternalSession(native.runner, native.externalSessionId, native.workspaceId);
         if (exact !== undefined &&
             exact.runner === native.runner &&
             exact.workspaceId === native.workspaceId &&
-            exact.externalSessionId === native.externalSessionId)
-            return exact;
-        return this.managedForNative(native);
-    }
-    managedForNative(native) {
-        if (native.externalSessionId === null)
-            return undefined;
-        const exact = this.options.runtime.findAgentSessionByExternalSession(native.runner, native.externalSessionId);
-        if (this.isManagedProjection(exact, native, false))
+            exact.externalSessionId === native.externalSessionId &&
+            (!managedOnly || exact.nativeControl === 'MAR_MANAGED'))
             return exact;
         const aliasId = this.options.runners
             .require(native.runner)
             .managedAliasId(native.externalSessionId);
-        const alias = aliasId === undefined ? undefined : this.options.runtime.getAgentSession(aliasId);
-        return this.isManagedProjection(alias, native, true) ? alias : undefined;
+        const alias = aliasId === undefined ? undefined : lookup.getAgentSessionById(aliasId);
+        // The Runner supplied the verified alias; Runtime may have promoted its old ID.
+        return alias !== undefined &&
+            alias.nativeControl === 'MAR_MANAGED' &&
+            alias.runner === native.runner &&
+            alias.workspaceId === native.workspaceId
+            ? alias
+            : undefined;
     }
     nativeIds(session) {
         const ids = new Set();
@@ -331,17 +342,6 @@ export class NativeSessionProjectionService {
             this.options.state.externalActivity.delete(projectionId);
         }
     }
-    isManagedProjection(candidate, native, allowAlias) {
-        const exactNativeId = candidate?.externalSessionId === native.externalSessionId;
-        const verifiedAlias = allowAlias &&
-            this.options.runners.require(native.runner).managedAliasId(native.externalSessionId ?? '') ===
-                candidate?.id;
-        return (candidate !== undefined &&
-            candidate.nativeControl === 'MAR_MANAGED' &&
-            candidate.runner === native.runner &&
-            candidate.workspaceId === native.workspaceId &&
-            (exactNativeId || verifiedAlias));
-    }
     requireDatabase() {
         const database = this.options.database();
         if (database === undefined)

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

@@ -84,13 +84,24 @@ export class SessionCatalogService {
             : query === undefined
                 ? await this.options.cachedWorkspace(workspaceId)
                 : await this.options.discoverWorkspace(workspaceId);
-        const native = nativeSessions.map((session) => this.options.present({ ...session, externalDiscovered: true }));
+        const inWorkspace = (session) => workspaceId === undefined || session.workspaceId === workspaceId;
+        const native = nativeSessions
+            .filter(inWorkspace)
+            .map((session) => this.options.present({ ...session, externalDiscovered: true }));
+        const projections = this.options.projection.projectionsForNative(native);
+        const sources = new Map();
+        for (const candidate of native) {
+            const projection = projections.get(candidate);
+            if (projection !== undefined && !sources.has(projection.id))
+                sources.set(projection.id, candidate);
+        }
         const projected = this.options.runtime
             .listAgentSessions()
+            .filter(inWorkspace)
             .filter((session) => session.nativeControl === 'MAR_MANAGED' ||
             (session.nativeControl === 'EXTERNAL' && session.externalSessionId !== null))
             .map((session) => {
-            const source = native.find((candidate) => this.options.projectionForNative(candidate)?.id === session.id);
+            const source = sources.get(session.id);
             const synchronized = session.titleSource !== 'AUTO' ||
                 source?.runnerTitle === undefined ||
                 source.runnerTitle === null
@@ -110,8 +121,7 @@ export class SessionCatalogService {
         });
         const merged = new Map([
             ...projected,
-            ...native.filter((candidate) => candidate.externalSessionId === null ||
-                this.options.projectionForNative(candidate) === undefined)
+            ...native.filter((candidate) => candidate.externalSessionId === null || projections.get(candidate) === undefined)
         ].map((session) => [session.id, session]));
         if (workspaceId !== undefined)
             this.mergePersisted(merged, workspaceId, !registeredOnly && query === undefined && this.options.discoveryPending(workspaceId));
@@ -268,8 +278,13 @@ export class SessionCatalogService {
             (await this.options.projection.resolve(input.sessionId));
         if (session === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        await this.removeResolved(session);
-        return { deleted: true };
+        try {
+            await this.removeResolved(session);
+            return { deleted: true };
+        }
+        finally {
+            this.options.invalidateWorkspaceSessions(session.workspaceId);
+        }
     }
     async cleanupWorkspaceSessions(input) {
         const inactiveDays = input.inactiveDays;
@@ -295,54 +310,58 @@ export class SessionCatalogService {
         let skipped = 0;
         let failed = 0;
         const deletedByRunner = {};
-        for (const session of candidates.values()) {
-            const missingCandidate = session.externalDiscovered === false;
-            if (session.externalSessionId === null ||
-                (missingCandidate &&
-                    (!this.options.runnerAvailable(session.runner) ||
-                        this.options.runtime.getAgentSession(session.id) !== undefined)) ||
-                (!missingCandidate &&
-                    Number.isFinite(session.lastActivityAt) &&
-                    session.lastActivityAt > 0 &&
-                    session.lastActivityAt >= cutoff) ||
-                (session.pinOrder !== null && session.pinOrder !== undefined) ||
-                this.options.isWatching(session.id) ||
-                this.options.isRecovering?.(session.id) ||
-                this.options.runtime.sessionQueue(session.id).itemIds.length > 0 ||
-                this.options.runtime
-                    .listRunsForSession(session.id)
-                    .some((run) => !isTerminalRunStatus(run.status)) ||
-                this.options.externalActivity(session.id) === 'BUSY') {
-                skipped += 1;
-                continue;
-            }
-            try {
-                if ((await this.removeResolved(session, true)) === 'deleted') {
-                    deleted += 1;
-                    deletedByRunner[session.runner] = (deletedByRunner[session.runner] ?? 0) + 1;
-                }
-                else
-                    skipped += 1;
-            }
-            catch (error) {
-                if (isCleanupSkip(error))
+        try {
+            for (const session of candidates.values()) {
+                const missingCandidate = session.externalDiscovered === false;
+                if (session.externalSessionId === null ||
+                    (missingCandidate &&
+                        (!this.options.runnerAvailable(session.runner) ||
+                            this.options.runtime.getAgentSession(session.id) !== undefined)) ||
+                    (!missingCandidate &&
+                        Number.isFinite(session.lastActivityAt) &&
+                        session.lastActivityAt > 0 &&
+                        session.lastActivityAt >= cutoff) ||
+                    (session.pinOrder !== null && session.pinOrder !== undefined) ||
+                    this.options.isWatching(session.id) ||
+                    this.options.isRecovering?.(session.id) ||
+                    this.options.runtime.sessionQueue(session.id).itemIds.length > 0 ||
+                    this.options.runtime
+                        .listRunsForSession(session.id)
+                        .some((run) => !isTerminalRunStatus(run.status)) ||
+                    this.options.externalActivity(session.id) === 'BUSY') {
                     skipped += 1;
-                else {
-                    failed += 1;
-                    nodeLog('workspace.session.cleanup.failed', {
-                        workspaceId: input.workspaceId,
-                        sessionId: session.id,
-                        runner: session.runner,
-                        ...cleanupFailureDiagnostic(error)
-                    });
+                    continue;
+                }
+                try {
+                    if ((await this.removeResolved(session, true)) === 'deleted') {
+                        deleted += 1;
+                        deletedByRunner[session.runner] = (deletedByRunner[session.runner] ?? 0) + 1;
+                    }
+                    else
+                        skipped += 1;
+                }
+                catch (error) {
+                    if (isCleanupSkip(error))
+                        skipped += 1;
+                    else {
+                        failed += 1;
+                        nodeLog('workspace.session.cleanup.failed', {
+                            workspaceId: input.workspaceId,
+                            sessionId: session.id,
+                            runner: session.runner,
+                            ...cleanupFailureDiagnostic(error)
+                        });
+                    }
                 }
             }
+            return { deleted, skipped, failed, deletedByRunner };
+        }
+        finally {
+            this.options.invalidateWorkspaceSessions(input.workspaceId);
         }
-        this.options.invalidateWorkspaceSessions(input.workspaceId);
-        return { deleted, skipped, failed, deletedByRunner };
     }
     cleanupCandidate(native) {
-        const projected = this.options.projectionForNative(native);
+        const projected = this.options.projection.projectionForNative(native);
         if (projected === undefined)
             return native;
         return {

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

@@ -1,7 +1,10 @@
+import { nodeLog } from '../operational.js';
+import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
 export class SessionIdentityService {
     options;
     bootstrapIds = new Set();
     waiters = new Map();
+    failedBootstrapIds = new Set();
     constructor(options) {
         this.options = options;
     }
@@ -9,6 +12,8 @@ export class SessionIdentityService {
         this.bootstrapIds.add(sessionId);
     }
     promote(sessionId, nativeSessionId) {
+        if (this.failedBootstrapIds.has(sessionId))
+            throw new Error('SESSION_START_FAILED');
         const current = this.options.runtime.getAgentSession(sessionId);
         this.options.runtime.promoteSessionIdentity(sessionId, nativeSessionId);
         if (current !== undefined)
@@ -45,9 +50,10 @@ export class SessionIdentityService {
             resolveIdentity = resolve;
             rejectIdentity = reject;
         });
+        // Startup may still be awaiting a command or the first message when identity fails.
+        void promise.catch(() => undefined);
         const timer = setTimeout(() => {
-            this.waiters.delete(bootstrapSessionId);
-            rejectIdentity(new Error('SESSION_NATIVE_ID_TIMEOUT'));
+            this.reject(bootstrapSessionId, 'SESSION_NATIVE_ID_TIMEOUT');
         }, 30_000);
         timer.unref();
         this.waiters.set(bootstrapSessionId, {
@@ -59,22 +65,39 @@ export class SessionIdentityService {
         return promise;
     }
     reject(sessionId, code) {
-        if (this.bootstrapIds.has(sessionId))
+        const bootstrap = this.bootstrapIds.has(sessionId);
+        if (bootstrap) {
+            this.failedBootstrapIds.add(sessionId);
             this.options.releaseAttachments?.(sessionId);
+        }
         const waiter = this.waiters.get(sessionId);
-        if (waiter === undefined)
+        if (waiter !== undefined) {
+            clearTimeout(waiter.timer);
+            this.waiters.delete(sessionId);
+            waiter.reject(new Error(code));
+        }
+        if (!bootstrap)
             return;
-        clearTimeout(waiter.timer);
-        this.waiters.delete(sessionId);
-        waiter.reject(new Error(code));
         queueMicrotask(() => {
-            try {
-                this.options.runtime.removeAgentSession(sessionId);
-                this.bootstrapIds.delete(sessionId);
-            }
-            catch {
-                // Runner cleanup may still own the bootstrap Session.
+            const session = this.options.runtime.getAgentSession(sessionId);
+            if (session?.id === sessionId) {
+                if (this.options.runtime
+                    .listRunsForSession(sessionId)
+                    .some((run) => !isTerminalRunStatus(run.status)))
+                    return;
+                try {
+                    this.options.runtime.removeAgentSession(sessionId);
+                }
+                catch (error) {
+                    nodeLog('session.bootstrap.cleanup.failed', {
+                        sessionId,
+                        error: error instanceof Error ? error.message.slice(0, 512) : 'Unknown cleanup error'
+                    });
+                    return;
+                }
             }
+            this.bootstrapIds.delete(sessionId);
+            this.failedBootstrapIds.delete(sessionId);
         });
     }
     dispose() {
@@ -84,5 +107,6 @@ export class SessionIdentityService {
         }
         this.waiters.clear();
         this.bootstrapIds.clear();
+        this.failedBootstrapIds.clear();
     }
 }

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

@@ -69,7 +69,9 @@ export class SessionLifecycleService {
         const next = nativeCodexRename
             ? this.options.runtime.setRunnerTitleFromNative(updated.id, input.customTitle ?? '')
             : updated;
-        if (sessionPrompt !== undefined)
+        if (sessionPrompt !== undefined ||
+            input.customTitle !== undefined ||
+            input.pinned !== undefined)
             this.options.emitSession(next);
         return { session: this.options.present(next) };
     }
@@ -77,7 +79,8 @@ export class SessionLifecycleService {
         if (typeof input.sessionId !== 'string' ||
             (input.direction !== 'up' && input.direction !== 'down'))
             throw new Error('SESSION_PIN_MOVE_INVALID');
-        this.options.database().movePinnedSession(input.sessionId, input.direction);
+        const workspaceId = this.options.database().movePinnedSession(input.sessionId, input.direction);
+        this.options.invalidateWorkspaceSessions(workspaceId);
         return { moved: true };
     }
     create(input) {

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

@@ -35,7 +35,9 @@ export class WorkspaceSessionService {
             return cached.sessions;
         let discovery = this.state.sessionCacheReads.get(workspaceId);
         if (discovery === undefined) {
-            const generation = this.cacheGenerations.get(workspaceId) ?? 0;
+            // A retired read must not regain ownership when its Workspace state is reclaimed.
+            const generation = Symbol();
+            this.cacheGenerations.set(workspaceId, generation);
             let resolveInitial;
             let rejectInitial;
             const initial = new Promise((resolve, reject) => {
@@ -52,7 +54,7 @@ export class WorkspaceSessionService {
             let batchPublished = false;
             let notifyCompletion = false;
             const publish = (sessions, notify = true) => {
-                if ((this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                if (this.cacheGenerations.get(workspaceId) !== generation)
                     return;
                 const previous = this.state.sessionCache.get(workspaceId)?.sessions;
                 this.state.sessionCache.set(workspaceId, {
@@ -66,7 +68,7 @@ export class WorkspaceSessionService {
             };
             const read = this.options
                 .discover(workspaceId, (runner, sessions) => {
-                if (!acceptingBatches || (this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                if (!acceptingBatches || this.cacheGenerations.get(workspaceId) !== generation)
                     return;
                 const previous = this.state.sessionCache.get(workspaceId)?.sessions;
                 const merged = [
@@ -81,7 +83,7 @@ export class WorkspaceSessionService {
                 resolveInitial(merged);
             })
                 .then((sessions) => {
-                if ((this.cacheGenerations.get(workspaceId) ?? 0) === generation)
+                if (this.cacheGenerations.get(workspaceId) === generation)
                     this.incompleteDiscoveries.delete(workspaceId);
                 const previous = this.state.sessionCache.get(workspaceId)?.sessions;
                 notifyCompletion =
@@ -93,7 +95,7 @@ export class WorkspaceSessionService {
             })
                 .catch((error) => {
                 rejectInitial(error);
-                if ((this.cacheGenerations.get(workspaceId) ?? 0) === generation) {
+                if (this.cacheGenerations.get(workspaceId) === generation) {
                     nodeLog('native.session.discovery.failed', { workspaceId });
                     const partial = this.state.sessionCache.get(workspaceId);
                     if (partial !== undefined)
@@ -111,11 +113,11 @@ export class WorkspaceSessionService {
                 }
                 if (this.initialReads.get(workspaceId) === initial)
                     this.initialReads.delete(workspaceId);
-                if (notifyCompletion && (this.cacheGenerations.get(workspaceId) ?? 0) === generation)
+                if (notifyCompletion && this.cacheGenerations.get(workspaceId) === generation)
                     this.options.invalidate(workspaceId);
                 if (!this.state.sessionCacheReads.has(workspaceId) &&
                     !this.state.sessionCache.has(workspaceId) &&
-                    (this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                    this.cacheGenerations.get(workspaceId) === generation)
                     this.cacheGenerations.delete(workspaceId);
             });
             discovery = read;
@@ -133,11 +135,7 @@ export class WorkspaceSessionService {
         this.state.sessionWatchTimers.clear();
         this.state.sessionWatchSignatures.clear();
         this.state.sessionWatchReads.clear();
-        for (const workspaceId of new Set([
-            ...this.state.sessionCache.keys(),
-            ...this.state.sessionCacheReads.keys()
-        ]))
-            this.bumpCacheGeneration(workspaceId);
+        this.cacheGenerations.clear();
         this.state.sessionCache.clear();
         this.state.sessionCacheReads.clear();
         this.initialReads.clear();
@@ -156,16 +154,13 @@ export class WorkspaceSessionService {
             this.staleDiscoveries.add(workspaceId);
     }
     invalidateCache(workspaceId) {
-        this.bumpCacheGeneration(workspaceId);
+        this.cacheGenerations.delete(workspaceId);
         this.state.sessionCache.delete(workspaceId);
         this.state.sessionCacheReads.delete(workspaceId);
         this.initialReads.delete(workspaceId);
         this.incompleteDiscoveries.delete(workspaceId);
         this.staleDiscoveries.delete(workspaceId);
     }
-    bumpCacheGeneration(workspaceId) {
-        this.cacheGenerations.set(workspaceId, (this.cacheGenerations.get(workspaceId) ?? 0) + 1);
-    }
     async refreshWatch(workspaceId) {
         const current = this.state.sessionWatchReads.get(workspaceId);
         if (current !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.62",
+  "version": "0.10.64",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.10.62",
+    "@myagentroam/agent": "0.10.64",
     "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/marctl": "0.10.12",
-    "@myagentroam/protocol": "0.10.62"
+    "@myagentroam/protocol": "0.10.64",
+    "@myagentroam/marctl": "0.10.12"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"